Python就业学习笔记

1·基础语法

1-1,输出Hello,World

print('Hello,World')

1-2，Python的导入位置

import os

print (os.getcwd())

1-3，Python的注释方法

# 注释内容

"""三引号注释的第一种
双引号形式，可以随意换行
"""

'''三引号注释的第一种
dan引号形式，可以随意换行
'''

1-4，input函数

# 一般用于输入信息

name = input('你的名字是：')

1-5，变量

# 一个拥有变量值的变量名等于变量
# 变量名必须是数字，字母，下划线组成，开头必须是字母或者下划线，变量名是区分大小写的

name = 'xiaoming'

# 快速定义变量
a, b, c = 1, 2, 3

1-6，Python的关键字

2.Python的数据类型

2-1，Pyhton的数据类型

数字类型，字符串类型，布尔类型，空类型，列表类型，元组类型，字典类型

2-2，数字类型

1.整型

整形就是我们说的整数，0也是整数，但是是特殊的整数

int既是整形的代表，又是定义整型的内置函数，但定义一个整型并不一定要使用int声明

2.浮点型

浮点型就是我们生活中的小数，凡是带有小数点的类型，都可以认为是浮点类型

在Python中，float既是浮点型的代表，又是定义浮点型的内置函数，但定义一个浮点型并不一定要使用float声明

3.type函数

作用：返回变量的类型

用法：type()括号里面填写已经定义的变量名或变量

number = 4.5

print(type(number)) # 可以直接使用变量
print(type(22)) #也可以直接传入数值

2-3，字符转

1.什么是字符串

用 '' 或 "" 包裹的信息就是字符串

字符串中可以包含任何字符，如字母，数字，符号，且没有先后顺序

在Python中，使用str来代表字符串类型，并且通过该函数可以定义字符串类型

2.id函数

作用：返回变量的内存地址

用法id()括号里面填写变量

num = 'hello'

print(id(num))

3.len函数

作用：返回字符串的长度，无法返回数字类型的长度，因为数字类型没有长度

用法：len()括号里面填写变量

test = len('这里测试len函数')

print(test)

4.内置成员运算符 in和not in的使用

in作用：判断你的数据中，是否存在你想要的成员,存在返回True,反之返回False

用法：字符 in 字符串

s = "hello liu xiyu"

print('xiyu' in s)

not in作用：判断你的数据中，是否不存在你想要的成员,不存在返回True,反之返回False

s = "hello liu xiyu"

print('xiyus' not in s)

5.max函数

作用：返回数据中最大的成员

顺序：中文符号 > 字母 > 数字 > 英文符号，中文按照拼音首字母计算

用法：max()括号里面填写数据

s = "今天是2023年4月2日"

print(max(s))

6.min函数

作用：返回数据中最小的成员

顺序：中文符号 > 字母 > 数字 > 英文符号，中文按照拼音首字母计算

用法：min()括号里面填写数据

s = "今天是2023年4月2日,星期日！"

print(min(s))

7.字符串的累加

字符串不是数字不能做减法，乘除法

字符串的拼接，用 + 这个符号

a = '123'
b = '456'
c = a + b

# 输出结果为 123456
print(c)

2-4,布尔类型与空类型

1.布尔类型

定义：真假的判断，即布尔类型

布尔值：True为真，False为假

在计算机中 0和1 是计算机最原始的形态，故而经常会将0,1来代替False,True

2.布尔(bool)函数的使用

作用：bool代表布尔类型，也可以对结果进行真假的判断

用法：bool()括号里面填写需要判断的数据

label = '我们在一起'

print(bool('我' in label))

3.空类型

定义：不属于任何数据类型，就属于空类型,属于False的范畴，如果不确定类型的时候，可以使用空类型

固定值：None

2-5，列表

1.什么是列表

列表就是队列，是各种数据的集合，也是一种数据结构，是一种有序，且内容可重复的集合类型

在Python中，list代表列表类型，也可以用它定义一个列表，列表的元素存在一个[]中

在Python中，列表是一个无限长度的内容结构

max 和 min 函数在列表中使用，需要保持数据类型一致

2-6，元组

1.什么是元组

元组与列表一样，都是一种可以存储多种数据结构的队列，元组也是一个有序的，且元素可以重复的集合，是一个无限制长度的数据集合

元组的定义：在Python中，tuple代表着元组这种类型，也可以用它定义一个元组，元组的元素存在()内

max 和 min 函数在元组中使用，需要保持数据类型一致

元组内容只有一个数据的时候要在后面加,

2.元组和列表的区别

• 元组比列表占用资源更小
• 列表是可变的，元组是不可变的

2-7，字典

1.什么是字典

字典是由多个键（key）及其对应的值（value）所组成的一种数据类型

2.字典的结构以及定义

在Python中，dict用来代表字典，并且可以创建一个字典

在Python中，通过{}将一个个key与value存入字典中

a = {key : value}

3.字典支持的数据类型

key支持字符串，数字和元组类型，不支持列表

value支持所有的数据类型

4.字典的重要特性

每个key都是唯一的

2-8，赋值运算符

赋值运算符有哪些

2-9，比较运算符

比较运算符有哪些

3-1 Python 字符串常用方法

1. 什么是对象

• Python 中一切都是对象
• 每个对象都有各自的属性和方法
• 对象的特点就是它的属性，功能就是方法

2. capitalize 的功能（首字母大写）

作用：

• 将字符串的首字母大写，其他字母小写

注意：

• 只对第一个字母有效
• 只对字母有效
• 已经是大写，则无效

用法：

newstr = string.capitalize() # 函数括弧内什么都不用写

3. casefold 与 lower 的用法 （转小写）

作用：

• 将字符串的字母改为小写

用法：

newstr = string.casefold() # 函数括弧内什么都不用填写
newstr = string.lower() # 函数括弧内什么都不用填写

注意：

• 只对字符串中的字母有效
• 已经是小写，则无效

4. upper 的用法 （转大写）

作用：

• 将字符串的字母改为大写

用法：

big_str = string.upper() # 函数括弧内什么都不用填写

注意：

• 只对字符串的字母有效
• 已经是大写，则无效

5. swapcase 的用法

作用：

• 将字符串中大小写字母进行转换（大转小，小转大）

用法：

newstr = string.swapcase() # 函数括弧内什么都不用填写

注意：

• 只对字符串中的字母有效

6. zfill 的用法

作用：

• 为字符串定义长度，如不满足，缺少的部分用 0 填补

用法：

# width:新字符串希望的宽度
newstr = string.zfill(width)

注意：

• 与字符串的字符无关
• 定义长度小于当前字符串长度，则不发生变化

7. count 的用法

作用：

• 返回当前字符串中某个成员（元素）的个数

用法：

# item:要查询个数的元素
inttype = string.count(item)

注意：

• 如果查询的成员（元素）不存在，则返回 0

8. startswith 和 endswith 的用法

作用：

• startswith 判断字符串开始位是否是某成员（元素）
• endswith 判断字符串结尾是否是某成员（元素）

用法：

# item:你想查询的元素，返回一个布尔值

start_test = string.startswith(item)

end_test = string.endswith(item)

9. find 和 index 的用法

作用：

• 返回你想寻找的成员的位置

用法：

# item:你想查询的元素，返回一个整型

string.find(item)

# item:你想查询的元素，返回一个整型或者报错

string.index(item)

# PS:字符串的位置从左到右，以 0 开始，空格也算字符串

区别：

• 如果 find 找不到元素，会返回 -1
• 如果 index 找不到元素，会导致程序报错

10. strip 的用法

作用：

• strip 将去掉字符串左右两边的指定元素，默认是空格

用法：

# item:你想去掉的元素，可不填写，默认空格

newstr = string.strip(item)

注意：

• 传入的元素如果不在开头或者结尾则无效
• lstrip 仅去掉字符串开头的指定元素或空格
• rstrip 仅去掉字符串结尾的指定元素或空格

11. replace 的功能

作用：

• 将字符串中的旧元素替换成新元素，并能指定替换的数量

用法：

'''
参数：
old : 被替换的元素
new : 替代 old 的新元素
max : 可选，代表替换几个，默认全部
如果需要修改多个字符，可以在后面再追加replace函数
newstr = string.replace(old,new).replace(old,new)
'''

newstr = string.replace(old,new,max)

3-2 字符串 bool 集合

1. isspace

功能：

isspace 判断字符串是否是一个由空格组成的字符串

用法：

# 无参数可传，返回一个布尔类型

booltype = string.isspace()

2. istitle

功能：

istitle 判断字符串是否是一个标题类型，只能用于英文

用法：

# 无参数可传，返回一个布尔类型

booltype = string.istitle()

3. isupper 与 islower

功能：

• isupper 判断字符串中的字母是否都是大写
• islower 判断字符中的字母是否都是小写

用法：

# 无参数可传，返回一个布尔类型

booltype = string.isupper()
booltype = string.islower()

3-3 字符串编码格式

1. 什么是编码格式

• 有一定规则的规则
• 使用了这种规则，我们就能知道传输的信息是什么意思

2. 常见编码格式

• gbk 中文编码
• ascii 英文编码
• utf-8 是一种国际通用的编码格式

3-4 字符串格式化

1. 什么是格式化

• 定义：一个固定的字符串中有部分元素是根据变量的值而改变的字符串

2. 格式化使用场景与目的

• 发邮件的时候
• 发短信的时候
• APP 上发推送的时候
• 对于重复性很多的信息，通过格式化的形式，可以减少代码的书写量

3. 根据类型定义的格式化

• 字符串格式化使用 % 来实现

# %s 格式符
# ('dewei', 33) 对应格式符的变量，按顺序一一对应，数量须保持一致，超过1个格式化变量用小括号包裹
# % 格式化字符串与格式符变量之间用一个 % 连接，% 两边有1个空格
'my name is %s, my age is %s' % ('dewei', 33)

• 字符串格式化函数 format

'''
format 函数用来格式化
字符串主题使用{},数字非必需
'''
'你好{0},今天看起来气色不错{1}'.format('小杨','不错')

• Python 3.6 新加入的 f-strings

'''
1.定义一个变量
2.字符串前加 f 符号
3.需要格式化的位置使用变量名
'''

name = '小杨'
age = 22
text = f'今天是{name}的{age}岁生日'
print (text)

3-5 格式化符号

定义：

• 用于对应各种数据类型的格式化符号

3-6 转义字符

1. 什么是转义字符

• 字符要转成其他含义的功能，所以我们叫他转义字符
• \ + 字符

2. Python 中的转义字符们

3. 转义无效符

• 在 Python 中，在字符串前加 r 来将当前字符串的转义字符无效化

print (r'hello \f')

3-2 Python 列表常用方法

1. append 的功能

功能：

• 将一个元素添加到当前的列表中

用法:

# new_item:添加进列表的新的元素（成员）
list.append(new_item)

注意：

• 被添加的元素只会被添加到末尾
• append 函数是在原有列表的基础上添加，不需要额外添加新的变量

2. insert 的功能

功能：

• 将一个元素添加到当前列表的指定位置中

用法：

# index:新的元素放在哪个位置（数字）
# new_item:添加进列表的新的元素（成员）

list.insert(index, new_item)

insert 与 append 的区别：

• append 只能添加到列表的结尾，insert 可以选择任何一个位置
• 如果 insert 传入的位置列表中不存在，则将新元素添加到列表结尾
• 字符串，元组，列表 元素的位置是从 0 开始计算的

3. 列表和元组的 count 函数

功能：

• 返回当前列表中某个成员的个数

用法：

# item:你想查询个数的元素

inttype = list.count(item)

注意：

• 如果查询的成员（元素）不存在，则返回 0
• 列表只会检查完整元素是否存在需要计算的内容

4. remove 的功能

功能：

• 删除列表中的某个元素

用法：

# item:准备删除的列表元素

list.remove(item)

注意：

• 如果删除的成员（元素）不存在，会直接报错
• 如果被删除的元素有多个，只会删除第一个
• remove 函数不会返回一个新的列表，而是在原先的列表中对元素进行删除

5. del 函数的功能

功能：

• del 把变量完全彻底删除

用法：

# string 要删除的变量
del string

6. reverse 的功能

功能：

• 对当前列表顺序反转

用法：

list.reverse()

7. sort 的功能

功能：

• 对当前列表按照一定规律进行排序

用法：

# key : 参数比较（key 涉及函数学习，我们在日后讲解当前默认不传即可
# reverse : 排序规则，reverse = True 降序，reverse = False 升序（默认）

list.sort(key = None, reverse = False)

注意：

• 列表中的元素类型必须相同，否则无法排序（报错）

8. clear 的功能

功能：

• 将当前列表中的数据清空

用法：

list.clear()

9. copy 的功能（浅拷贝）

功能：

• 将当前的列表复制一份相同的列表，新列表与旧列表内容相同，但内存空间不同

用法：

# 该函数无参数，返回一个一模一样的列表
list.copy()

copy 与二次复制的区别：

• 二次赋值的变量与原始变量享有相同内存空间
• copy 函数创建的新列表与原始列表不是一个内存空间，不同享数据变更

浅拷贝：

深拷贝：

10. extend 的功能（导入列表或元组）

功能：

• 将其他列表或元组的元素倒入到当前列表中

用法：

# iterable 要导入的列表或元组，无返回值

list.extend(iterable)

3-3 列表索引

1. 什么是索引

• 字符串，列表和元组
• 从最左边记录的位置就是索引
• 索引用数字表示，起始从 0 开始
• 字符串，列表（元组）的最大索引是他们的长度 - 1

2. 什么是切片

• 索引用来对单个元素进行访问，切片则对一定范围内的元素进行访问
• 切片通过冒号在中括号内把相隔的两个索引查找出来 [0: 10]
• 切片规则为：左含，右不含

3. 列表的索引，获取与修改

• list[index] = new_item
• 数据的修改只能在存在的索引范围内
• 列表无法通过添加新的索引方式赋值
• list.index(item)

4. pop 的功能

功能：

• 通过索引删除并获取列表的元素

用法：

# index 删除列表的第几个元素
# 函数会删除该索引的元素并返回，如果传入的 index 索引不存在则报错

list.pop(index)

5. 通过 del 删除索引

用法：

# 直接删除 无返回值
# 如果 index （索引）不存在则报错

del list[index]

6. 索引切片在元组中的特殊性

• 可以和列表一样获取索引与切片索引
• 元组函数 index 和列表用法完全一致

7. 列表之字符串切片

字符串的索引与获取：

• 一个字符对应一个索引
• 索引规则与列表相同
• 切片和索引的获取与列表相同
• 无法通过索引修改与删除，字符串不可修改

3-4 Python 字典常用方法

1. [] 添加或修改处理法

功能：

• 添加或修改字典

用法：

# 字典没有索引
# 添加或修改，根据 key 是否存在所决定

dict['name'] = 'dewei'

2. update 的功能与用法

功能：

• 添加新的字典
• 如新字典中有和原字典相同的 key ，则会被新字典覆盖

用法：

# new_dict:新的字典,该函数无返回值

dict.update(new_dict)

3. setdefault 的功能

功能：

• 获取某个 key 的 value
• 如 key 不存在字典中，将会添加 key 并将 value 设为默认值

用法：

# key:需要获取的 key
# value:如果 key 不存在，对应这个 key 存入字典的默认值

dice.setdefault(key,value)

4. 注意事项再强调

• 字典中每一个 key 一定是唯一的
• 字典中的数据量没有限制
• 字典中的 value 可以是任何 python 的内置数据类型的对象和自定义的对象

5. keys 的功能

功能：

• 获取当前字典中所有的键 (key)

用法：

# 返回一个 key 集合的伪列表，伪列表不具备列表的所有功能

dict.keys()

6. values 功能

功能：

• 获取当前字典中所有键值对中的值 (value)

用法：

# 返回一个 value 集合的伪列表，伪列表不具备列表的所有功能

dict.values()

7. 字典 key 的获取

1. [] 的获取方法：

• 字典 + 中括号内传入 key ，不进行赋值操作，即为获取
• 返回 key 对应的 value 值

例子：

name = dict['key']

2. get 功能

功能：

• 获取当前字典中指定 key 的 value

用法：

# key:需要获取 value 的 key
# default:key 不存在则返回此默认值，默认是 None,我们也可以自定义

dict.get(key,default=None)

3. [] 与 get 的区别

• [] 如果获取的 key 不存在，则直接报错
• get 如果获取的 key 不存在，则返回默认值
• 在开发中，优先使用 get 函数

8. 字典删除

1. clear功能

功能：

• 清空当前字典中所有数据

用法：

dict.clear()

2. pop 功能

功能：

• 删除字典中指定的 key ，并将其结果返回
• 如果 key 不存在则报错

用法：

# key:希望被删掉的键，返回这个 key 对应的值(value)

dict.pop(key)

3. del 在字典中的用法

功能：

• 删除字典指定的 key 或者指定的完整字典

用法：

dict = {'name' : 'xiaoming', 'age' : 33}

del dict['name'] # 删除指定 key
del dict # 删除指定字典

9. copy 的功能

功能：

• 将当前字典复制一个新的字典

用法：

# 该函数无参数
# 返回一个一模一样的内存地址不同的字典

dict.copy()

10. 字典成员运算符

1. in 与 not in 在字典中的用法

• 只能判断 key 是否存在

2. get 判断成员是否存在

11. popitem 功能

功能：

• 删除当前字典里末尾一组键值对并将其返回

用法：

# 返回被删除的键值对，用元组包裹 0 索引是 key, 1 索引是 value

dict.popitem()

注意：

• 如果字典为空，则直接报错

12. 数据类型与布尔值的关系

• 每一种数据类型，自身的值都有表示 True 与 False
• not 对于一切结果取反

Python 的集合

1. 什么是集合

• 集合（set）是一个无序的不重复的元素序列
• 常用来对两个列表进行交并差的处理性
• 和列表一样，支持所有数据类型
• 重复的元素会被去除

2. 集合与列表的区别

3. 集合的创建

• 通过 set 函数来创建集合，不能使用 {} 来创建空集合

a_set = set() # 空集合
a_set = set([1, 2, 3]) # 传入列表或元组
b_set = {1, 2, 3} # 传入元素
c_set = {} # 空 {} 表示字典

4. 集合的增删改

4.1 add 的功能

功能：

用于在集合中添加一个元素，如果集合中已存在该元素则该函数不执行

用法：

set.add(item) # item:要添加的元素，无返回值

4.2 update 的功能

功能：

加入一个新的集合（或列表，元组，字符串），如新集合的元素在原集合中存在则无视

用法：

set.update(iterable) # iterable:集合，无返回值，直接作用于原集合

4.3 remove 的功能

功能：

将集合中的某个元素删除，如元素不存在将会报错

用法：

set.remove(item) # item:要删除的元素,无返回值，直接作用于原集合

4.4 clear 的功能

功能：

清空当前集合中的所有元素

用法：

set.clear() # 无返回值，直接作用于原集合

4.5 del 的功能

功能：

删除集合

用法：

del a_set # a_set:要删除的集合

4.6 重要说明

• 集合无法通过索引获取元素
• 集合无获取元素的任何方法
• 集合只是用来处理列表或元组的一种临时类型，他不适合存储与传输

5. 获取两个集合的差集

5.1 什么是差集

• 简单说就是 a 有的，但 b 没有的
• a, b 两个集合，由所有属于 a 且不属于 b 的元素组成的集合叫做 a 与 b 的差集

5.2 difference 的功能

功能：

返回集合的差集（即返回的集合元素包含在第一个集合中，但不包含在第二个集合中）

用法：

# b_set:当前集合需要对比的集，返回 a_set 与 b_set 的差集

a_set.difference(b_set) 

示例：

a_set = {'name', 'xiaomu', 'xiaoming'}

b_set = {'xiaoming', 'xiaogang', 'xiaohong'}

a_diff = a_set.difference(b_set)

print(a_diff)

6. 获取两个集合的交集

6.1 什么是交集

• a, b 都有的就是交集
• a, b 两个集合分别拥有的相同的元素集，称为 a 与 b 的交集

6.2 intersection 的功能

功能：

返回两个或更多集合中都包含的元素，即交集

用法：

# b_set... : 与当前集合对比的 1 或多个集合，返回原始集合与对比集合的交集

a_set.intersection(b_set...)

示例：

a_set = {'Python', 'PHP', 'JAVA'}

b_set = {'HTML', 'IOS', 'Python'}

a_inter = a_set.intersection(b_set)

print(a_inter)

7. 获取两个集合的并集

7.1 什么是并集

• a, b 加在一起
• a, b 两个集合中所有的元素（去掉重复）即为 a 与 b 的交集

7.2 union 的功能

功能：

返回多个集合的并集，既包含了所有集合的元素，重复的元素只会出现一次

用法：

# b_set... : 与当前集合对比的 1 或 多个集合，返回原始集合与对比集合的并集

a_set.union(b_set...)

示例：

a_set = {'Python', 'PHP', 'JAVA'}

b_set = {'HTML', 'IOS', 'Python'}

un = a_set.union(b_set)

print(un)

8. 判断两个集合中是否有相同的元素

8.1 isdisjoint 的功能

功能：

判断两个集合是否包含相同的元素，如果没有则返回 True, 否则返回 False

用法：

# b_set : 与当前集合用来判断的集合，返回一个布尔值 True 或 False

a_set.isdisjoint(b_set)

示例：

a_set = {'Python', 'PHP', 'JAVA'}

b_set = {'HTML', 'IOS', 'Python'}

result = a_set.isdisjoint(b_set)

print(result)

Python不同数据类型间的转换

1. 字符串与数字的转换

1.1 什么是类型转换，为何做类型转换

• 将自身数据类型变成新的数据类型，并拥有新的数据类型的所有功能的过程即为类型转换
• 为方便更好的帮助处理业务，将类型变更为更适合业务场景的类型

1.2 字符串与数字之间转换的要求

• 字符串转数字：要求是数字组成的字符串
• 数字转字符串：无要求

1.3 字符串与数字之间的转换函数

2. 字符串与列表之间的转换

2.1 字符串转列表之 split 功能

功能：

将字符串以一定规则切割转成列表

用法：

# sep:切割的规则符号，不填写，默认空格，如字符串无空格则不分割生成列表
# maxsplit: 根据切割符号切割的次数，默认-1无限制
# 返回一个列表

string.split(sep=None, maxsplit=-1)

示例：

info = 'my name is dewei'
info_list = info.split()

print(info_list)

2.2 列表转字符串之 join 功能

功能：

将列表以一定规则转成字符串

用法：

# sep: 生成字符串用来分割列表每个元素的符号
# iterable: 非数字类型的列表或元组或集合
# 返回一个字符串

'sep'.join(iterable)

示例：

test = ['a', 'b', 'c']
new_str = '.'.join(test)

print(new_str)

3. 字符串与 bytes 的转换

3.1 什么是比特类型

• 二进制的数据流 --- byte
• 一种特殊的字符串
• 字符串前 + b 标记

3.2 字符串转 bytes 的函数 - encode 功能

功能：

• 将字符串转成比特 (bytes) 类型

用法：

# encoding: 转换成的编码格式，如ascii，gbk，默认 utf-8
# errors: 出错时的处理方法，默认strict,直接抛错误，也可以选择 ignore 忽略错误
# 返回一个比特 (bytes) 类型

string.encode(encoding='utf-8', errors='strict')

示例：

str_data = 'my name is dewei'

byte_data = str_data.encode('utf-8')

print (byte_data)

3.3 bytes转字符串的函数--decode

功能：

• 将比特 (bytes) 类型转成字符串

用法：

# encoding: 转换成的编码格式，如ascii，gbk，默认 utf-8
# errors: 出错时的处理方法，默认strict，直接抛错误，也可以选择 ignore 忽略错误
# 返回一个字符串类型

bytes.decode(encoding='utf-8',errors='strict')

示例：

byte_data = b'python is good code'

str_data = byte_data.decode('utf-8')

print (str_data)

4. 元组，列表，集合间的转换

4.1 列表元组集合之间的转换函数

Python 流程控制

1. if 语句的功能

功能：

判断一个命题的真实性，如果命题为真（True) 则执行 if 的逻辑语句

用法：

# bool_result : 判断结果的真假，布尔类型
# do : 如果布尔为 True 时执行任意代码
# if 属于关键字，没有返回值

if bool_result : # 语法块
    do           # 业务代码块，注意缩进

2. else 语句的功能

功能：

当 if 语句不满足时所执行的代码块的入口

用法：

# elsedo : else 语句对应的 Python 代码块
# else 属于语法，没有返回值

if bool_result : # if 语法块
    do           # 业务代码块，注意缩进
else :
    elsedo       # else 语法块，需缩进

3. elif 的功能

功能：

对于首次 if 判断不满足后，其他条件的判断语句

用法：

# elif 属于语法，没有返回值

if bool_result :   # if 语法块
    do             # 业务代码块，注意缩进
elif bool_result : # elif 语法块
    elifdo         # 业务代码块，注意缩进
else :
    elsedo         # else 语法块，需缩进

4. 条件语句的说明

• 条件语句中满足一个条件后，将退出当前条件语句
• 每个条件语句中仅有且必须有一个 if 语句，可以有 0 个或多个 elif 语句，可以有 0 或1个 else 语句
• 每个条件语句 if 必须是第一个条件语

5. for 循环（遍历）

功能：

通过 for 关键字将列表，元组，字符串,字典中的每个元素按照序列顺序进行遍历(循环）

用法：

# iterable : 可循环的数据类型,如列表,元组,字符串,字典
# item     : iterable 中的每一个元素（成员）
#          ： for 循环是语句，没有返回值，但在特定情况下有返回值

for item in iterable:  # for 循环代码块
    print(item)        # 每次循环对应的代码块

6. 字典利用 items 内置函数进行 for 循环

功能：

将字典转成伪列表，每个 key，value 转成元组

用法：

# key   : for 循环体中获取的字典当前元素的 key
# value : for 循环体中对应当前 key 的 value 值
# for 循环是语句，没有返回值，items 返回一个为列表

for key, value in dict.items():
    print (key, value)

7. range 函数

功能：

返回的是一个一定范围的可迭代对象，元素为整型，他不是列表，无法打印信息，但可循环

用法：

# start : 开始的数字，类似索引的左边
# stop : 结束的数字，类似索引的右边
# step : 跳步，类似索引中的第三个参数
# 返回一个可迭代(循环)的以整型为主的对象

for item in range(start, stop, step=1):
    print(item)

8. else 在 for 循环中的使用

• else 语句只有在 fo r循环正常退出后执行
• 循环没有报错，没有中途停止

9. 嵌套 for 循环

示例：

# 执行流程如下：首先输出 a 变量的第一个元素，然后依次输出 b 变量所有元素，输出完毕后，再输出 a 变量第二个元素，以此类推

a = [1, 2, 3]
b = [4, 5, 6]

for i in a:
    print(i)
    print('-------')
    for j in b:
        print(j)
    print('--------')

10. while 循环

功能：

在满足条件下会无限循环，不满足条件后将停止循环

用法：

# bool_result : 布尔类型，此处语法与 if 完全一致
# do : while 循环体的代码块
# while 循环是语句，没有返回值

while bool_result:
    do

11. continue 的功能

功能：

循环遇到 continue 将停止本次数据循环，进入下一次循环

用法：

# continue: 属于语法，不需要加 () 即可，没有返回值
while bool:
    continue
for item in iterable:
    continue
    print(item)

示例：

# 示例：
count = 1
while count < 5:
    print(count)
    continue
    count += 1

12. break 的功能

功能：

使循环正常停止循环(遍历)，这时如果循环配合了 else 语句，else 语句将不执行

用法：

# break: 属于语法，不需要加 () 即可，没有返回值
while bool:
    break
for item in iterable:
    print(item)
    break

示例：

# 示例：
count = 1
while count < 5:
    print(count)
    count += 1
    break

函数的定义与使用

1. 函数的定义

• 将一件事情的步骤封装在一起并得到最终结果
• 函数名代表了这个函数要做的事情
• 函数体是实现函数功能的流程
• 方法或功能
• 函数可以帮助我们重复使用，通过函数名我们可以知道函数的作用

2. 函数的分类

• 内置函数
• 自定义函数

3. 通过关键字 def 定义函数

def name(args...):
    todo something..
    返回值

4. 通过关键字 def 函数执行

def say_hello():
    print('今天没有程序，只有笔记')

say_hello() #函数名+小括号执行函数

5. 函数结果的返回-- return

• 将函数结果返回的关键字
• return 只能在函数体内使用
• return 支持返回所有的 python 类型
• 有返回值的函数可以直接赋值给一个变量

例子：

def add(a, b):
    c = a + b
    return c
result = add(a=1, b=1) # 参数按顺序传递
print(result)

6. return 与 print 的区别

• print 只是单纯的将对象打印，不支持赋值语句
• return 是对函数执行结果的返回，也支持赋值语句

7. 函数的参数

7.1 必传参数

• 函数中定义的参数没有默认值，在调用函数时如果不传入则报错
• 在定义函数的时候，参数后边没有等号与默认值
• 错误: def add (a=1,b=1) x
• 总结：在定义函数的时候，没有默认值且必须在函数执行的时候传递进去的参数就是必传参数

7.2 默认参数

• 在定义函数的时候，定义的参数含有默认值，就说他是一个默认参数

7.3 不确定参数——可变参数

• 没有固定参数的函数，需要传递不确定参数 (不知道要传的参数名具体是什么)

  def add(*args, **kwargs):
      pass
  add(1, 2, 3, name = 'dewei', age = 33)

• *args 代表: 将无参数的变量合并成元组
• **kwargs 代表将有参数与默认值的赋值语句合并成字典

7.4 参数规则

def add(a, b=1, *args, **kwargs)

• 参数的定义从左到右依次是 必传参数，默认参数，可变元组参数，可变字典参数
• 函数的参数传递非常灵活
• 必传参数与默认参数的传参多样化

8. 函数的参数类型定义

• 函数定义在 python 3.7 之后可用
• 函数不会对参数类型进行验证

# name: 参数名+冒号+类型函数
# age: 参数名+冒号+类型函数+等号+默认值

def person(name:str, age:int=33):
    print(name,age)

9. 局部变量与全局变量

9.1 全局变量

• 在python脚本最上层代码块的变量
• 全局变量可以在函数内被读取使用

示例：

# coding:utf-8

name = 'dewei'

def test():
    print(name)

9.2 局部变量

• 在函数体内定义的变量
• 局部变量无法在自身函数以外使用

# coding:utf-8

def test():
    name = 'dewei'
    print(name)
    
print(name)

9.3 global

功能：

• 将全局变量可以在函数体内进行修改

用法：

# coding:utf-8

name = 'dewei'

def test():
    global name
    name = '小杨'
test() # 改完不要忘了执行，否则输出的还是 dewei
print(name)

10. 递归函数

作用：

一个函数不停地将自己反复执行,类似于 while 循环

用法：

def test(a):
    print(a)
    return test(a) # 通过返回值，直接执行自身函数就达到了递归的效果

示例：

count = 0

def test():
    global count
    count += 1

    if count != 5:
        print('count条件不满足， 我要重新执行我自己!当前count是%s' % count)
        return test()
    else:
        print('count is %s' % count)
test()

11. lambda 匿名函数

功能：

• 定义一个轻量化函数
• 即用即删除，很适合需要完成一项功能，但是此功能只在此一处使用

用法：

# 第一种方式，无参数方式
f = lambda : print('无参数方式')
f()

# 第二种方式,有参数方式
f = lambda x, y: x * y
print(f(3, 4))

Python 面向对象与异常处理机制

1. 面向对象

1.1 什么是面向对象：

• 利用 (面向)对象(属性与方法) 去进行编码的过程
• 自定义对象数据类型就是面向对象中的类 (class) 的概念

1.2 类的关键字 class

• class 来声明类，类的名称首字母大小多单词情况下每个单词首字母大写（驼峰命名）

1.3 类的定义

用法：

class Name(object):
    attr = something
    
    def func(self):
        do

示例：

class Cat(object):
    # 类的属性
    color = 'black'

    # 类的方法（函数）
    def eat(self):
        print('我喜欢吃鱼')

    def sleep(self):
        print('我要睡觉了')

cat = Cat() # 类的实例化
print(cat.color) # 通过实例化进行属性调用
cat.eat() # 通过实例化进行函数调用

1.4 类的参数 self

• self 是类函数中的必传参数，且必须放在第一个参数位置
• self 是一个对象，他代表实例化的变量自身
• self 可以直接通过点来定义一个类变量
• self 中的变量与含有 self 参数的函数可以在类中的任何一个函数内随意调用
• 非函数中定义的变量在定义的时候不用 self

1.5 类的构造函数

功能：

类中的一种默认函数， 用来将类实例化的同时， 将参数传入类中

用法：

def _init_(self, a, b):
    self.a = a
    self.b = b

示例：

class Like(object):
    # 类的属性
    age = 22

    # 类的方法（函数）
    def __init__(self, name):
        self.name = name

    def ilove(self):
        return '我喜欢小刘'


like = Like(name='小杨')  # 类的实例化,同时传入我的名字
print('大家好，我的名字是', like.name, like.ilove())

1.6 对象的生命周期

• __开头__结尾的类函数都是类的默认函数

2. 类中的私有函数与私有变量

2.1 什么是私有函数私有变量

• 无法被实例化后的对象调用的类中的函数与变量
• 类内部可以调用私有函数与变量
• 只希望类内部业务调用使用，不希望被使用者调用

2.2 私有函数与私有变量的定义方法

• 在变量或函数前添加 __ (2个下横线)，变量或函数名后边无需添加

示例：

class Cat(object):
    def __init__(self, name):
        self.name = name

    def run(self):
        pass

    def __run(self):
        return f'小猫 {self.name} 开心地奔跑着'

    def dump(self):
        result = self.__dump() # 此处在类内调用私有函数
        print(result)

    def __dump(self):
        return f'小猫 {self.name} 开心的跳着'

cat = Cat('羊羊羊')
# cat.__run() 实例化会报错，私有函数（方法）无法调用，有直接输出私有函数的方法，不推荐，不做展示
cat.dump() # 由 dump() 函数调用私有函数 __dump()

3. Python 中的封装

• 将不对外的私有属性或方法通过可对外使用的函数而使用(类中定义私有的,只有类内部使用,外部无法访问
• 这样做的主要原因: 保护私隐，明确区分内外

示例：

class Parent (object):
    def __hello(self,data):
        print(f'hello{data}')

    def helloword(self):
        self.__hello('world')

parent = Parent()
parent.helloword()

4. 装饰器

4.1 什么是装饰器

• 也是一种函数
• 可以接受函数作为参数
• 可以返回函数
• 接收一个函数，内部对其处理，然后返回一个新函数，动态的增强函数功能
• 将b函数在a函数中执行，在a函数中可以选择执行或不执行b函数，也可以对b函数的结果进行二次加工处理

4.2 装饰器的定义

定义：

def out(func_args): #外围函数
    def inter(*args, **kwargs): # 内嵌函数
        return func_args(*args, **kwargs)
    return inter #外围函数返回内嵌函数

示例：

def log(func):
    def wrapper():
        print(f'call {func.__name__}')
        func()
    return wrapper

@log # 调用装饰器
def hello():
    print('hello world')

hello() # 调用装饰器

4.3 装饰器的用法

• 将被调用的函数直接作为参数传入装饰器的外围函数括弧【例1】
• 将装饰器与被调用函数绑定在一起
• @ 符号 + 装饰器函数放在被调用函数的上一行，下一行创建函数只需要直接调用被执行函数即可【例2】

例 1：

def a(func):
    def b(*args, **kwargs):
        return func(*args, **kwargs)
    return b

def c(name):
    print(name)

a(c('羊羊羊'))

例 2 ：

def a(func):
    def b(*args, **kwargs):
        return func(*args, **kwargs)
    return b

@a
def c(name):
    print(name)

c('羊羊羊')

5. 类的常用装饰器

5.1 classmethod 的功能

功能：

• 将类函数可以不经过实例化而直接被调用

用法：

# cls : 替代普通类函数中的 self，变为 cls，代表当前操作的是类
@classmethod
def func(cls, ...):
        do

示例：

class Test_01(object):
    @classmethod
    def add(cls, a, b):
        print(a + b)

Test_01.add(1, 2) # 无需实例化，直接调用

5.2 staticmethod 的功能

功能：

• 将类函数可以不经过实例化而直接被调用
• 被该装饰器调用的函数不许传递self或cls参数，且无法再该函数内调用其它类函数或类变量

用法：

# 函数体内无 cls 或 self 参数
@staticmethod
def func(...):
    do

示例：

class Test_01(object):
    @staticmethod
    def add(a, b): # 无 cls 或 self 参数
        print(a + b)

Test_01.add(1, 2) 

5.3 property 的功能

功能：

• 将类函数的执行免去括弧，类似于调用属性( 变量 )

用法：

@property
def func(self):
    do

示例：

class Test_01(object):
    def __init__(self, name):
        self.name = name

    @property
    def call_name(self):
        return f'hello {self.name}'

test_01 = Test_01('小杨') # 实例化类，并传入参数
result = test_01.call_name # 使用 property 装饰器，将类函数的执行免去括弧
print(result) # 

5.4 三个函数的练习

class Test_01(object):
    def __init__(self, name):
        self.name = name

    @property
    def call_name(self):
        return f'hello {self.name}'

    @classmethod
    # cls : 替代普通类函数中的 self，变为 cls，代表当前操作的是类
    def add(cls, a, b):
        print(a + b)

    @staticmethod
    def sta_test(a, b):  # 无 cls 或 self 参数
        print(a + b)

# 使用 property 装饰器，将类函数的执行免去括弧
test_01 = Test_01('小杨') # 实例化类，并传入参数
result = test_01.call_name
print(result)

# 使用 classmethod 装饰器，无需实例化直接运行
Test_01.add(1, 4)

# 使用 staticmethod 装饰器，无需实例化直接运行
Test_01.sta_test(3, 4)