大家好，又见面了，我是你们的朋友全栈君。

在这里插入图片描述

文章目录

题外话
前言
1. Python能用来干嘛
2. 安装Python和HelloWorld
- 2.1 下载
- 2.2 shell命令
- 2.3 第一个程序
3. 输入输出
- 3.1 输入
- 3.2 输出
- 3.3 使用
4. 基本语法
- 4.1 缩进
- 4.2 注释
- 4.3 标识符
- 4.4 保留字
5. 常量变量运算符
- 5.1 常量
- 5.2 变量
- 5.3 运算符
6. 数据类型
- 6.1 基本数据类型
- 6.2 高级数据类型
7. 分支控制语句
- 7.1 循环控制语句
- - 7.1.1 for循环
  - 7.1.2 while循环
- 7.2 条件控制语句
- 7.3 break
- 7.4 continue
8. 函数式编程
- 8.1 作用
- 8.2 定义
- - 8.2.1 无参函数
  - 8.2.2 有参函数
- 8.3 返回值
- 8.4 优点
- 8.5 缺点
9. 面向对象编程
- 9.1 作用
- 9.2 使用
- 9.3 定义
- 9.4 构造方法
- 9.5 封装
- 9.6 继承
- 9.7 魔术方法
10. 进阶操作
- 10.1 异常处理
- 10.2 文件操作
- 10.3 常用模块
- 10.4 多线程
- 10.5 pymysql
- 10.6 模块与包
- - 10.6.1 模块
  - 10.6.2 包

题外话

? 博客主页：❤布小禅❤
? 作者专栏：
❤Python❤
❤Java❤

前言

现在不是一直都在吹Python吗，说什么小学都要出Python的教材了，搞得好像这年头不会个Python还不如小学生一样！

既然如此，那么？你会Python吗？

不会？不要紧！一篇文带你入门Python！一篇文带你疏通Python基础语法！

会？行吧，别急着走嘛！看看吧。毕竟，温故而知新，可以为师矣！

Python作为一门高级编程语言吗，最大的特点就是简单易学

来看看Python是如何在C/C++，Java等语言中脱颖而出的吧

1. Python能用来干嘛

由于Python的第三方类库实在是太多了，因此它能做的事情也是极多的，甚至你也可以自己做一些类库放在网上让别人使用。

这其一呢，Python可以做我们的PC客户端，也就是PC端的QQ，百度网盘之类的需要下载安装的软件

这其二呢，Python还能做点PC端的小游戏，比如什么植物大战僵尸，魂斗罗，飞机大战的

这其三呢，Python还能搭建网站，做我们经常用的类似于百度，CSDN，华为云社区这些

这其四呢，Python还可以做网络爬虫，就是不需要我们手动的去网络上下载数据，代码一键把所有数据拿下来（当然也很有风险）

这其五呢，Python可以做数据分析，就是把我们从网络上爬取的数据进行分类，放在一起，便于查询，把我们不需要的数据丢掉之类的

这其六呢，Python还可以做AI，也就是人工智能

这其七呢，Python可以做自动化办公，也就是自动填写表格，自动处理数据之类的

这其八呢，Python还可以做自动化运维

当然除了这些，还能做些别的，我就不一一道来了，因为一个人精力有限，也是没法全部学完的，就说这么多吧

…

2. 安装Python和HelloWorld

2.1 下载

可以去官网下载——官网

下载后傻瓜式安装，不过有一步需要注意的是：Add to path的地方需要勾一下

不勾选的话需要手动配置环境，异常麻烦

2.2 shell命令

安装好以后，我们Ctrl + R输入cmd打开命令行

在命令行输入我们所学语言的名字：python

会看到这个符号：>>> 这个就是Python自带的交互模式

2.3 第一个程序

而我们只需要输入print("HelloWorld")

就能让计算机给我们显示一个HelloWorld出来

而在括号里面，引号里面，我们可以进行修改，来改变屏幕显示的内容

引号的意思：引号在Python里面是有字符串的意思

当然，你也可以在括号里面输入1+1等运算来让计算机给你计算结果

3. 输入输出

顾名思义，输入就是你用键盘输入，输出就是计算机输出给你内容

3.1 输入

输入我们需要用到一个内置函数：input()汉语意思也是输入，在Python中的作用也是输出

觉得不好理解可以这么理解：

input()表示我对电脑说的话

3.2 输出

输出我们需要用到一个内置函数：print()汉语意思是打印，就是打印内容到你的屏幕上

而这个print函数，也是我们HelloWorld入门实战的函数

print()表示电脑对我说的话

3.3 使用

设计一个小程序实现输入什么内容就输出什么内容

代码：

print(input())  
# 意思是在输出函数里面使用输入函数

看着很简单，但是其实还设计了函数返回值的知识，这里就只提一下

在input()函数的括号里可以像print()函数一样写东西，他会在你运行代码之后显示

你可以用这个来设置输入的提示信息

4. 基本语法

每个语言都有自己的语法，不同语言的语法也不尽相同

4.1 缩进

在别的语言中使用大括号来表示一个代码块

而在Python中使用缩进来规定一个代码块

缩进一般以四个空格为标准

缩进错误会报错显示语法错误

错误缩进：

print("aa")
 print("bb")

正确缩进：

print("aa")
 print("bb")

4.2 注释

给自己的程序添加注释是很有必要的

俗话说得好：

程序员最讨厌给自己的代码写注释，更讨厌别人的代码不写注释

单行注释
- # 我是单行注释
多行注释
- “”“多行注释”””
‘’‘多行注释’’’

两种多行注释都能当字符串使用

一定要养成写注释的好习惯，这很重要

4.3 标识符

程序员自己命名的
有自己的规范
- 包含数字，字母，下划线
- 不能以数字开头
- 大小写敏感
- 一般采用驼峰命名法
  - 首字母小写，其他单词首字母大写
  - peopleName这样
- 类名建议首字母大写

一定要遵循规范，这很重要

4.4 保留字

官方规定的具有某种特定意义的单词
标识符不能用保留字
Python有33个保留字
也叫关键字
所有符号都用英文半角符号

诸如def class等不是内置函数的单词

def class if for while 等等等

5. 常量变量运算符

5.1 常量

值无法改变的量

例如数字1
例如字符串”hello world”
等等

print(1)

5.2 变量

值能改变的量

名字为标识符
使用赋值符号 = 给变量复制
- a = 1这样

a = 1
b = "www"
print(a,b)
# 1www

5.3 运算符

5.3.1 算术运算符

加：+
减：-
乘：*
除：/

print(1+1)  # 2
print(10-2) # 8
print(10*2) # 20
print(10/2) # 5

5.3.2 比较运算符

大于：>
小于：<
大于等于：>=
小于等于：<=

print(1==2) # False
print(1>2) # False
print(10>=5) # True
print(5<=1)  # Fasle

5.3.3 赋值运算符

直接赋值：=
相加赋值：+=
相乘赋值：*=
…

i = 10  # 给i赋值为10
print(i+=1)  # 让i加1
print(i*=2)  # 让i乘2

6. 数据类型

6.1 基本数据类型

整型
- 1
- 100
浮点型
- 1.1
- 10.1
布尔型
- True
- False
复数类型
- 5j+1
- 1+3j

6.2 高级数据类型

6.2.1 字符串

“hello”
‘hello’
‘’‘hello’’’
“”“hello”””

""" 例子：给出一个变量a = 1 怎么让输出的结果为：“a的值为：1” 第一个方法：print(“a的值为：”, a) 第二个方法：print(“a的值为：{}”.format(a)) 第三个方法：print(“a的值为：%d”%a) 第四个方法：print(f"a的值为：{a}") 其实就是让我们的字符串中可以添加变量，而第一种的方法在处理一个字符串中的多个变量时是较为麻烦的，这时候就需要用到下面三个，比较简单，我最喜欢的是第四个方法。因为写出来简单 """
a = 1
print(“a的值为：”, a)
print(“a的值为：{ 
   }”.format(a))
print(“a的值为：%d”%a)
print(f"a的值为：{a}")
# 原生字符串和非原生字符串
# 看代码看差异
# 1. 原生字符串
print(r'\n\t')
# 2. 非原生
print('\n\t')

6.2.2 列表

[1, 2, 3, 4]
[‘a’, ‘b’, ‘c’, ‘d’]
[True, False, False]

增删改查：

li = [1, 2, 3, 4]
li.append(5)  # [1, 2, 3, 4, 5]
li.remove(5)  # [1, 2, 3, 4]
li[0] = 10  # # [10, 2, 3, 4]
print(li[0], li[1])

6.2.3 元组

(1, 2, 3, 4)
(‘a’, ‘b’, ‘c’, ‘d’)

增删：

tu = (1, 2, 3, 4)
tu1 = (5,)
tu2 = tu+tu1  # (1, 2, 3, 4, 5)
del tu  # 全部删除

6.2.4 字典

{‘a’: 1, ‘b’: 2}
{1: ‘a’, 2:‘b’}

增删改查：

dic = { 
   'a': 1, 'b': 2}
dic['c'] = 3  # {'a': 1, 'b': 2, 'c': 3}
del dic['c']  # {'a': 1, 'b': 2}
dic['a'] = 10 # {'a': 10, 'b': 2}
print(dic['a']) # 10

6.2.5 集合

(1, 2, 3, 4)
(‘a’, ‘b’,‘c’)

增删：

se = { 
   1, 2, 3, 4}
se.add(5)  # {1, 2, 3, 4, 5}
se.remove(5)  # {1, 2, 3, 4}
se.clear() # 全部删除

6.2.6 下标

下面的可以用下标来访问该下标的值，下标从0开始

print("hello"[0])  # h
print([1, 2, 3, 4][1]) # 2
print({ 
   1, 2, 3, 4}[2]) # 3
print((1, 2, 3, 4)[3]) # 4
# 下标：0 1 2 3
print({ 
   'a': 1, 'b': 2}['a']) # 1
# 字典以键取值，前面是键，后面是值

6.2.7 切片，步长

对这些类型取某些值，而不是单一的值

print("hello"[0:2])  # 切片出he
print([1, 2, 3, 4][0:3:2]) # 从下标0到3每二个取[1, 3]
# print({1, 2, 3, 4}[0:1] # 会报错，因为集合具有无序性
print((1, 2, 3, 4)[3])

7. 分支控制语句

7.1 循环控制语句

7.1.1 for循环

for i in range(10):
    print(i)
# 也可以对高级数据类型进行这样的操作
a = "Hello World!"
for i in range(10):
    print(a)

7.1.2 while循环

i = 0
while i<10:
    print(i)
# 也可以对高级数据类型进行这样的操作
a = "Hello World!"
i = 0
while i<10:
    print(a[i])
    i+=1

7.2 条件控制语句

7.2.1 if单支

a = int(input("请输入一个整数"))
b = int(input("请输入一个整数"))
c = a+b
if c<10:
    print("两数之和小于10")

7.2.2 if…else…

a = int(input("请输入一个整数"))
b = int(input("请输入一个整数"))
c = a+b
if c<10:
    print("两数之和小于10")
else:
    print("两数之和大于10")

7.2.3 if…elif…elif…else…

a = int(input("请输入一个整数"))
b = int(input("请输入一个整数"))
c = a+b
if c<10:
    print("两数之和小于10")
elif c==10:
    print("两数之和等于10")
else:
    print("两数之和大于10")

7.3 break

打破分支语句
使分支语句终止

while True:
    a = input()
    if a == "q":
        break
    else:
        print(a + " 输入成功，输入 'q' 退出程序")

7.4 continue

跳过分支语句
进行下一次分支语句

for i in range(10):
    if i % 5 == 0:        
        continue
    else:        
        print(i)

8. 函数式编程

8.1 作用

减少代码重用率
加快开发效率

8.2 定义

使用关键字：def定义

8.2.1 无参函数

# 定义
def Qinghua():
    print("我爱你")
    print("我要给你生猴子")
    print("啊啊啊，好喜欢你")
# 调用
Qinghua()
def fun():
    print("我是无参函数")
fun()

8.2.2 有参函数

def PinJie(a, b):
    str_ = str(a)+str(b)
    print(str_)
    for i in str_:
        print(i)

PinJie("sasa", 4564)
#也可以这么写
""" PinJie(a="sasa",b=4564) 这样写的好处是 就算你的位置写错了 参数传递的也还是对的 也就是说，参数传递的位置不固定 就像这样 PinJie (b=4564, a='sasa') 是完全一样的 """

8.3 返回值

return
用于将函数变成变量使用

函数名字(参数)就是返回的值

def PinJie(a, b):
    str_ = str(a)+str(b)
    return str_

p = PinJie("sasa", 4564)
print(p)

8.4 优点

效率高
简单

8.5 缺点

不易维护
开发效率较面向对象低

9. 面向对象编程

9.1 作用

提升开发效率
增加维护性

9.2 使用

定义抽象化的类
既实例化对象

9.3 定义

使用class关键字定义

三种定义方法

class Person1:    
    pass

class Person2():    
    pass

class Person3(object):    
    pass
# 使用实例化对象
p1 = Person1()
p2 = Person2()
p3 = Person3()

9.4 构造方法

def __init__(self):   
    pass
# 给类传参
class Person3(object):
    def __init__(self, name, age):   
        pass
p3 = Person3('a', 12)

9.5 封装

在构造方法里self.属性 = 属性
在属性名前面加 _
在方法名前面加 _

# 在构造方法里self.属性 = 属性
class Person1(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

Menger = Person("萌杰尔", 20)

name = Menger.name
age = Menger.age
print("姓名：{} \n年龄：{}".format(name, age))
# 在属性名前面加 _
class Person2(object):
    _weight = 70
    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height
 
    def weightPrint(self):
        print("我的体重是：", self._weight)

person = Person("布小禅", 20, 180)
person.weightPrint()
# 在方法名前面加 _
class Person3(object):
    def _love(self):
        print("我暗恋Xxx")
    
    def speakLove(self):
        self._love()

9.6 继承

在定义类的时候，写在类名后面的括号里
Python支持多继承
class Person(object, class1, class2): pass
继承后，该类拥有所继承的类里面的所有方法和属性

class Person(object):

    def __init__(self, name, age):
        self.name = name
        self.age = age
            
    def speak(self):
        print(f"{self.age}岁的{self.name}会说话")
class Boy(object,Person):
    pass
boy = Boy ("Menger", 20)
boy.speak()

9.7 魔术方法

_init_ 构造方法
_str_ 使实例化对象变成字符串
_new_ 先于构造方法被执行
_call_ 使实例化对象拥有函数性质
_del_ 实例化对象被删除时执行

class Person(object):
    def __str__(self):
        return "我是__str__方法的返回值，显示在打印实例化对象时"
    def __del__(self):
        print("我没用了，我被删除了")
    def __new__(cls):
        print("我是__new__方法")
        return super().__new__(cls)
    def __call__(self):
        print("执行了__call__方法")
        return "我是返回值"

p = Person()
print(p)

10. 进阶操作

10.1 异常处理

try:…except:…finally:…

冒号后面接回车
- try后面跟有可能错误的代码
- except后面跟如果错了怎么办
- finally后面跟不管错没错都要执行的代码

try:
    print(a)
except:
    print("小伙子，我不认识什么是a啊")
finally:
    print("好好写代码，不要老是报错了啊")

10.2 文件操作

内置函数open()
- open(“文件名”, “读取方式”)
  - w只写
r只读
- w+读写
wb以二进制写
- rb以二进制读
wa追加写入

""" 测试文件为text.txt 内容为： 我是text.txt 我的作用是测试文件操作 """
f = open('text.txt', 'r', encoding='utf-8')
# 用变量接收，以便于后面的操作
ree = f.read()  # 读取全部
li = f.readlines()  # 按行读取全部行
rre = f.readline()  # 只读取一行
# 测试三个函数，运行的时候，记得把别的注释掉
# 原因是第一个函数已经把文件的指针挪到最后了，第二个函数就读不到东西
print(ree)
f.close()
# 使用完记得关闭文件，免得消耗资源，使得程序报个内存溢出的错
f = open('text.txt', 'w', encoding='utf-8')
f.write("我是使用write函数写入的")
f.close()
# 这个方法会覆盖原来的，想继续写，只能使用追加方式
f = open('text.txt', 'wa', encoding='utf-8')
f.write("我是使用write函数写入的")
f.write("我是使用write函数写入的")
f.write("我是使用write函数写入的")
f.write("我是使用write函数写入的")
f.close()

10.3 常用模块

10.3.1 os模块

路径，文件，sys

参考我之前的博客：os模块的简单使用

10.3.2 time模块

计时，时间

import time
start = time.time() # 当前时间戳
a = 1000**100000
end = time.time() # 获取计算完成的时间戳
runTime = end - start # 计算所花的时间
print("本次计算耗时：{}".format(runTime))

10.3.3 random模块

随机数

import random
# 生成10个0-10的证书
for i in range(10):
    print(random.randint(0,10))

# 生成10个0-1的数
for i in range(10):
    print(random.random())

10.3.4 re模块

正则表达式

""" 正则表达式用于提取字符串中的某些数据 """
import re
# 定义一个字符串
a = "大连科技动拉网红豆味"
# 提取科技两个字
print(re.findall("大连(.*?)动", a))

10.4 多线程

要先了解进程，线程的区别

进程：

拿电脑举例子的话，进程就是QQ，微信等不同的程序

拿py文件举例子的话，就是你的多几个py文件

线程：

拿电脑举例子的话，就是QQ，微信里你能和好多人一起聊天

拿py文件举例子的话，就是你在py文件里的许多函数

10.4.1 无序性

多线程具有无序性：

既任务不会按顺序完成

代码：

import threading
def speak(a=list):
    for i in a:
        print("我是",i,"\n")

li = [1, 2, 3, 4, 5, 6, 7]
li2 = ['1', '2', '3', '4', '5', '6', '7']

s1 = threading.Thread(target=speak, args=(li,))
s2 = threading.Thread(target=speak, args=(li2,))
s1.start()
s2.start()

运行结果：

""" 我是 1 我是 我是1 2 我是 我是2 3 我是 3 我是 我是4 4 我是5 5 我是 我是6 6 我是 我是7 7 """

10.4.1 自定义线程类

class MyThead(threading.Therad):
    def __init__(self,n):
         super(MyThread,self).__init__()   #重构run函数必须写
         self.n = n
    def run(self) -> None:
        speak(li)
        speak(li2)
        return super().run()
    
def speak(a=list):
    for i in a:
        print("我是",i,"\n")

li = [1, 2, 3, 4, 5, 6, 7]
li2 = ['1', '2', '3', '4', '5', '6', '7']
s1 = MyThead('1')
s2 = MyThead('2')
s1.start()
s2.start()

10.4.3 守护线程

如果不设置守护线程，那么主线程退出后，其他线程仍会执行直到执行完毕才会退出

线程默认不是守护线程，设置守护线程的方法是设置线程函数的参数daemon=True

import threading
def speak():
    print("aaa")
    
t1 = threading.Thread(target=speak, daemon=True)
t2 = threading.Thread(target=speak)
t3 = threading.Thread(target=speak)

10.5 pymysql

使用Python链接数据库

import pymysql
pymsql.connect(host='127.0.0.1',port=3306, user='你自己的账号', passwd='你自己的密码', db='你的数据库')

执行语句：

# 获取游标
cos = con.cursor(pm.cursors.DictCursor)
sql = cos.execute("select * from 你自己的数据表")
# 查看查询结果
print(sql)

关闭连接：

con.close()
cos.close()

10.6 模块与包

10.6.1 模块

模块是一个py文件

我们自己创建一个py文件就是一个模块

我们可以对他进行导入的操作，然后使用

自定义模块：textmodel.py
```
def print_f(a):
    print(a)
    
```

另一个py文件：模块.py

导入的时候记得要让两个文件同路径

我们导入自定义模块，然后使用自定义函数

# 第一种方法
import textmodel
textmodel.print_f("第一种方法：直接导入 测试成功")
# 第二种方法
from textmodel import print_f
print_f("第二种方法：精确导入某函数 测试成功")
# 第三种方法
import textmodel as tm
tm.print_f("第三种方法：导入起别名 测试成功")

导入别人的模块和内置模块也可以这样

项目文件夹：

10.6.2 包

包就是一个含有__init__.py的文件夹

我们在项目目录下创建一个文件夹text，然后在里面放一个__init__.py的文件

这样就是一个包了

在text文件夹新建一个textpackage.py
```
def print_f(a):
    print(a)
    
```

和text同目录的模块.py文件

from text import textpackeg
textpackeg.print_f("包测试成功")