笔记说明 :由于本人学习python 已经有 Java  和  web 基础 所以笔记记录的很简单 仅限参考

注释

注释的作用

通过⽤⾃⼰熟悉的语⾔，在程序中对某些代码进⾏标注说明，这就是注释的作⽤，能够⼤⼤增强程序的可读性

注释的分类及语法

注释分为两类：单⾏注释 和 多⾏注释

单⾏注释 只能注释⼀⾏内容，语法如下：

## 注释内容

多⾏注释

可以注释多⾏内容，⼀般⽤在注释⼀段代码的情况， 语法如下：

"""
 第⼀⾏注释
 第⼆⾏注释
 第三⾏注释
"""

'''
 注释1
 注释2
 注释3
'''

变量

变量名⾃定义，要满⾜标识符命名规则

语法:

变量名 = 值

标识符命名规则是Python中定义各种名字的时候的统⼀规范，具体如下：

  • 由数字、字⺟、下划线组成
  • 不能数字开头
  • 不能使⽤内置关键字
  • 严格区分⼤⼩写

要做到:

  • ⻅名知义。
  • ⼤驼峰：即每个单词⾸字⺟都⼤写，例如： MyName 。
  • ⼩驼峰：第⼆个（含）以后的单词⾸字⺟⼤写，例如： myName 。
  • 下划线：例如： my_name 。

以下都是系统保留词:

False None True and as assert break class 
continue def del elif else except finally for
from global if import in is lambda nonlocal
not or pass raise return try while with 
yield

使⽤变量

my_name = 'TOM'
print(my_name)
schoolName = '⿊⻢程序员'
print(schoolName)

数据类型

*检测数据类型的⽅法： *

type()

```plain
a = 1
print(type(a)) ## <class 'int'> -- 整型


b = 1.1
print(type(b)) ## <class 'float'> -- 浮点型


c = True
print(type(c)) ## <class 'bool'> -- 布尔型


d = '12345'
print(type(d)) ## <class 'str'> -- 字符串


e = [10, 20, 30]
print(type(e)) ## <class 'list'> -- 列表


f = (10, 20, 30)
print(type(f)) ## <class 'tuple'> -- 元组


h = {10, 20, 30}
print(type(h)) ## <class 'set'> -- 集合

Python 类型 有如下:

  • 整型：int
  • 浮点型：flfloat
  • 字符串：str
  • 布尔型：bool
  • 元组：tuple
  • 集合：set
  • 字典：dict

格式化输出

普通输出:

print('hello Python')

格式化符号:

| 格式符号 | 转换 |
| — | — |
| %s | 字符串 |
| %d | 有符号的⼗进制整数 |
| %f | 浮点数 |
| %c | 字符 |
| %u | ⽆符号⼗进制整数 |
| %o | ⼋进制整数 |
| %x | ⼗六进制整数（⼩写ox） |
| %X | ⼗六进制整数（⼤写OX） |
| %e | 科学计数法（⼩写'e'） |
| %E | 科学计数法（⼤写'E'） |
| %g | %f和%e的简写 |
| %G | %f和%E的简写 |

小技巧:

  • %06d，表示输出的整数显示位数，不⾜以0补全，超出当前位数则原样输出
  • %.2f，表示⼩数点后显示的⼩数位数。

f 格式化

格式化字符串除了%s，还可以写为 f'{表达式}'

age = 18
name = 'TOM'
weight = 75.5
student_id = 1

## 我的名字是TOM
print('我的名字是%s' % name)


## 我的学号是0001
print('我的学号是%4d' % student_id)


## 我的体重是75.50公⽄
print('我的体重是%.2f公⽄' % weight)


## 我的名字是TOM，今年18岁了
print('我的名字是%s，今年%d岁了' % (name, age))

## 我的名字是TOM，明年19岁了
print(f'我的名字是{name}, 明年{age + 1}岁了')

f-格式化字符串是Python3.6中新增的格式化⽅法，该⽅法更简单易读。

转义字符

  • ：换⾏。

  • \t ：制表符，⼀个tab键（4个空格）的距离。

结束符

print('输出的内容', end="
")   ## 默认结束 
  所以才会自动换行

输入

语法:

input("提示信息")

实例:

password = input('请输⼊您的密码：')
print(f'您输⼊的密码是{password}')
## <class 'str'>
print(type(password))

输⼊的特点

  • ⼀般将input接收的数据存储到变量
  • input接收的任何数据默认都是字符串数据类型

转换数据类型

| 函数 | 说明 |
| — | — |
| int(x [,base ]) | 将x转换为⼀个整数 |
| float(x ) | 将x转换为⼀个浮点数 |
| complex(real [,imag]) | 创建⼀个复数，real为实部，imag为虚部 |
| str(x ) | 将对象 x 转换为字符串 |
| repr(x ) | 将对象 x 转换为表达式字符串 |
| eval(str ) | ⽤来计算在字符串中的有效Python表达式,并返回⼀个对象 |
| tuple(s ) | 将序列 s 转换为⼀个元组 |
| list(s ) | 将序列 s 转换为⼀个列表 |
| chr(x ) | 将⼀个整数转换为⼀个Unicode字符 |
| ord(x ) | 将⼀个字符转换为它的ASCII整数值 |
| hex(x ) | 将⼀个整数转换为⼀个⼗六进制字符串 |
| oct(x ) | 将⼀个整数转换为⼀个⼋进制字符串 |
| bin(x ) | 将⼀个整数转换为⼀个⼆进制字符串 |
| | |
| | |
| | |
| | |
| | |
| | |

实例:

## 1. float() -- 转换成浮点型
num1 = 1
print(float(num1))
print(type(float(num1)))


## 2. str() -- 转换成字符串类型
num2 = 10
print(type(str(num2)))


## 3. tuple() -- 将⼀个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))


## 4. list() -- 将⼀个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))
print(type(list(t1)))


## 5. eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))

运算符

分类

  • 算数运算符
  • 赋值运算符
  • 复合赋值运算符
  • ⽐较运算符
  • 逻辑运算符

算数运算符

| 运算符 | 描述 | 实例 |
| — | — | — |
| + | 加 | 1 + 1 输出结果为 2 |
| - | 减 | 1-1 输出结果为 0 |
| * | 乘 | 2 * 2 输出结果为 4 |
| / | 除 | 10 / 2 输出结果为 5 |
| // | 整除 | 9 // 4 输出结果为2 % 取余 9 % 4 输出结果为 1 |
| | 指数 | 2 4 输出结果为 16，即 2 2 2 * 2 |
| () | ⼩括号 | ⼩括号⽤来提⾼运算优先级，即 (1 + 2) * 3 输出结果为 9 |

赋值运算符

| = | 赋值 | 将 = 右侧的结果赋值给等号左侧的变量 |
| — | — | — |

多个变量赋值:

num1, float1, str1 = 10, 0.5, 'hello world'
print(num1)
print(float1)
print(str1)
#多变量赋相同值
a = b = 10
print(a)
print(b)

复合赋值运算符

| 运算符 | 描述 | 实例 |
| — | — | — |
| += | 加法赋值运算符 | c += a 等价于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等价于 c = c- a |
| = | 乘法赋值运算符 | c = a 等价于 c = c a |
| /= | 除法赋值运算符 | c /= a 等价于 c = c / a |
| //= | 整除赋值运算符 | c //= a 等价于 c = c // a |
| %= | 取余赋值运算符 | c %= a 等价于 c = c % a |
| = | 幂赋值运算符 | c = a 等价于 c = c * a |

⽐较运算符

⽐较运算符也叫关系运算符， 通常⽤来判断。

实例:

a = 7 b = 5
print(a == b) ## False
print(a != b) ## True
print(a < b) ## False
print(a > b) ## True
print(a <= b) ## False
print(a >= b) ## True

逻辑运算符

a = 1 b = 2 c = 3
print((a < b) and (b < c)) ## True
print((a > b) and (b < c)) ## False
print((a > b) or (b < c)) ## True
print(not (a > b)) ## True

拓展

a = 0 b = 1 c = 2
## and运算符，只要有⼀个值为0，则结果为0，否则结果为最后⼀个⾮0数字
print(a and b) ## 0
print(b and a) ## 0
print(a and c) ## 0
print(c and a) ## 0
print(b and c) ## 2
print(c and b) ## 1
## or运算符，只有所有值为0结果才为0，否则结果为第⼀个⾮0数字
print(a or b) ## 1
print(a or c) ## 2
print(b or c) ## 1

条件语句 IF

语法

if 条件:
 条件成⽴执⾏的代码1
 条件成⽴执⾏的代码2
 ......


if 条件:
 条件成⽴执⾏的代码1
 条件成⽴执⾏的代码2
 ......
else:
 条件不成⽴执⾏的代码1
 条件不成⽴执⾏的代码2
 ......



if 条件1:
 条件1成⽴执⾏的代码1
 条件1成⽴执⾏的代码2
 ......
elif 条件2：
 条件2成⽴执⾏的代码1
 条件2成⽴执⾏的代码2
 ......
......
else:
 以上条件都不成⽴执⾏执⾏的代码

嵌套

if 条件1：
 条件1成⽴执⾏的代码
 条件1成⽴执⾏的代码

    if 条件2：
         条件2成⽴执⾏的代码
         条件2成⽴执⾏的代码

实例:

if True:
 print('条件成⽴执⾏的代码1')
 print('条件成⽴执⾏的代码2')
## 下⽅的代码没有缩进到if语句块，所以和if条件⽆关
print('我是⽆论条件是否成⽴都要执⾏的代码')

random模块

语法:

import 模块名

使⽤random模块中的随机整数功能

random.randint(开始,结束)

三⽬运算符

语法:

条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式

```python
a = 1
b = 2
c = a if a > b else b
print(c)

循环

while

语法:

while 条件:
 条件成⽴重复执⾏的代码1
 条件成⽴重复执⾏的代码2
 ......

```plain
#求 1-100的累加和，即1 + 2 + 3 + 4 +….，
i = 1
result = 0
while i <= 100:
 result += i
 i += 1
## 输出5050
print(result)

break和continue

理解:

举例：⼀共吃5个苹果，吃完第⼀个，吃第⼆个…，这⾥“吃苹果"的动作是不是重复执⾏？

情况⼀：如果吃的过程中，吃完第三个吃饱了，则不需要再吃第4个和第五个苹果，即是吃苹果的动作停⽌，这⾥就是break控制循环流程，即终⽌此循环。

情况⼆：如果吃的过程中，吃到第三个吃出⼀个⼤⾍⼦…,是不是这个苹果就不吃了，开始吃第四个苹果，这⾥就是continue控制循环流程，即退出当前⼀次循环继⽽执⾏下⼀次循环代码。

for循环

语法:

for 临时变量 in 序列:
 重复执⾏的代码1
 重复执⾏的代码2
 ......

```plain
str1 = 'itheima'
for i in str1:
 print(i)

while…else

while 条件:
 条件成⽴重复执⾏的代码
else:
 循环正常结束之后要执⾏的代码

for…else

for 临时变量 in 序列:
 重复执⾏的代码
 ...
else:
    循环正常结束之后要执⾏的代码

字符串

⼀对引号字符串

name1 = 'Tom'
name2 = "Rose"

三引号字符串

三引号形式的字符串⽀持换⾏

name3 = ''' Tom '''
name4 = """ Rose """
a = ''' i am Tom,
 nice to meet you! '''


b = """ i am Rose,
 nice to meet you! """

下标

“下标” ⼜叫 “索引” ，就是编号。⽐如⽕⻋座位号，座位号的作⽤：按照编号快速找到对应的座位。同理，下标的作⽤即是通过下标快速找到对应的数据。

字符串 name = “abcdef” ，取到不同下标对应的数据

name = "abcdef"
print(name[1])
print(name[0])
print(name[2])

切⽚

切⽚是指对操作的对象截取其中⼀部分的操作。字符串、列表、元组都⽀持切⽚操作

语法

序列[开始位置下标:结束位置下标:步⻓]

注意
1. 不包含结束位置下标对应的数据， 正负整数均可；
2. 步⻓是选取间隔，正负整数均可，默认步⻓为1。

```python
name = "abcdefg"
print(name[2:5:1]) ## cde
print(name[2:5]) ## cde
print(name[:5]) ## abcde
print(name[1:]) ## bcdefg
print(name[:]) ## abcdefg
print(name[::2]) ## aceg
print(name[:-1]) ## abcdef, 负1表示倒数第⼀个数据
print(name[-4:-1]) ## def
print(name[::-1]) ## gfedcba

字符串常用操作

字符串的常⽤操作⽅法有查找、修改和判断三⼤类

查找

所谓字符串查找⽅法即是查找⼦串在字符串中的位置或出现的次数。

find()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则返回-1。

语法

 ## 字符串序列.find(⼦串, 开始位置下标, 结束位置下标)

mystr = "hello world and itcast and itheima and Python"
print(mystr.find('and')) ## 12
print(mystr.find('and', 15, 30)) ## 23
print(mystr.find('ands')) ## -1

index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则

报异常

rfifind()： 和fifind()功能相同，但查找⽅向为右侧开始。

rindex()：和index()功能相同，但查找⽅向为右侧开始。

语法

字符串序列.index(⼦串, 开始位置下标, 结束位置下标)

开始和结束位置下标可以省略，表示在整个字符串序列中查找
mystr = "hello world and itcast and itheima and Python"
print(mystr.index('and')) ## 12
print(mystr.index('and', 15, 30)) ## 23
print(mystr.index('ands')) ## 报错

count()：返回某个⼦串在字符串中出现的次数

语法

字符串序列.count(⼦串, 开始位置下标, 结束位置下标)
开始和结束位置下标可以省略，表示在整个字符串序列中查找

mystr = "hello world and itcast and itheima and Python"
print(mystr.count('and')) ## 3
print(mystr.count('ands')) ## 0
print(mystr.count('and', 0, 20)) ## 1

修改

replace()：替换

语法

字符串序列.replace(旧⼦串, 新⼦串, 替换次数)

mystr = "hello world and itcast and itheima and Python"
## 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he'))
## 结果：hello world he itcast he itheima he Python
print(mystr.replace('and', 'he', 10))
## 结果：hello world and itcast and itheima and Python
print(mystr)

数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型

split()：按照指定字符分割字符串。

语法

字符串序列.split(分割字符, num)
num表示的是分割字符出现的次数，即将来返回数据个数为num+1个


mystr = "hello world and itcast and itheima and Python"
## 结果：['hello world ', ' itcast ', ' itheima ', ' Python']
print(mystr.split('and'))
## 结果：['hello world ', ' itcast ', ' itheima and Python']
print(mystr.split('and', 2))
## 结果：['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']
print(mystr.split(' '))
## 结果：['hello', 'world', 'and itcast and itheima and Python']
print(mystr.split(' ', 2))

join()：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。

语法

字符或⼦串.join(多字符串组成的序列) 

list1 = ['chuan', 'zhi', 'bo', 'ke']
t1 = ('aa', 'b', 'cc', 'ddd')
## 结果：chuan_zhi_bo_ke
print('_'.join(list1))
## 结果：aa...b...cc...ddd
print('...'.join(t1))

capitalize()：将字符串第⼀个字符转换成⼤写

mystr = "hello world and itcast and itheima and Python"
## 结果：Hello world and itcast and itheima and python
print(mystr.capitalize())
## capitalize()函数转换后，只字符串第⼀个字符⼤写，其他的字符全都⼩写。

title()：将字符串每个单词⾸字⺟转换成⼤写

lower()：将字符串中⼤写转⼩写

upper()：将字符串中⼩写转⼤写。

lstrip()：删除字符串左侧空⽩字符。

rstrip()：删除字符串右侧空⽩字符。

strip()：删除字符串两侧空⽩字符。

ljust()：返回⼀个原字符串左对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串。

语法

字符串序列.ljust(⻓度, 填充字符)

rjust()：返回⼀个原字符串右对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和ljust()相同。

center()：返回⼀个原字符串居中对⻬,并使⽤指定字符(默认空格)填充⾄对应⻓度 的新字符串，语法和ljust()相同。

判断

所谓判断即是判断真假，返回的结果是布尔型数据类型：True 或 False

startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

语法:

字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)
mystr = "hello world and itcast and itheima and Python "
## 结果：True
print(mystr.startswith('hello'))
## 结果False
print(mystr.startswith('hello', 5, 20))

endswith()：：检查字符串是否是以指定⼦串结尾，是则返回 True，否则返回 False。如果设置开

始和结束位置下标，则在指定范围内检查。

mystr = "hello world and itcast and itheima and Python"
## 结果：True
print(mystr.endswith('Python'))
## 结果：False
print(mystr.endswith('python'))
## 结果：False
print(mystr.endswith('Python', 2, 20))

isalpha()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False。

mystr1 = 'hello'
mystr2 = 'hello12345'
## 结果：True
print(mystr1.isalpha())
## 结果：False
print(mystr2.isalpha())

isdigit()：如果字符串只包含数字则返回 True 否则返回 False。

mystr1 = 'aaa12345'
mystr2 = '12345'
## 结果： False
print(mystr1.isdigit())
## 结果：False
print(mystr2.isdigit())
12345678

isalnum()：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返 回 True,否则返回False。

mystr1 = 'aaa12345'
mystr2 = '12345-'
## 结果：True
print(mystr1.isalnum())
## 结果：False
print(mystr2.isalnum())

isspace()：如果字符串中只包含空⽩，则返回 True，否则返回 False

mystr1 = '1 2 3 4 5'
mystr2 = ' '
## 结果：False
print(mystr1.isspace())
## 结果：True
print(mystr2.isspace())

列表

列表的格式

[数据1, 数据2, 数据3, 数据4......]

查找

name_list = ['Tom', 'Lily', 'Rose']
print(name_list[0]) ## Tom
print(name_list[1]) ## Lily
print(name_list[2]) ## Rose

函数

列表序列.index(数据, 开始位置下标, 结束位置下标)

name_list = ['Tom', 'Lily', 'Rose']
print(name_list.index('Lily', 0, 2)) ## 1



count()：统计指定数据在当前列表中出现的次数

name_list = ['Tom', 'Lily', 'Rose']
print(name_list.count('Lily')) ## 1


len()：访问列表⻓度，即列表中数据的个数。
name_list = ['Tom', 'Lily', 'Rose']
print(len(name_list)) ## 3

判断是否存在

in：判断指定数据在某个列表序列，如果在返回True，否则返回False
not in：判断指定数据不在某个列表序列，如果不在返回True，否则返回False


name_list = ['Tom', 'Lily', 'Rose']
## 结果：True
print('Lily' in name_list)
## 结果：False
print('Lilys' in name_list)


    name_list = ['Tom', 'Lily', 'Rose']
## 结果：False
print('Lily' not in name_list)
## 结果：True
print('Lilys' not in name_list)

增加

语法

列表序列.append(数据) 

name_list = ['Tom', 'Lily', 'Rose']
name_list.append('xiaoming')
## 结果：['Tom', 'Lily', 'Rose', 'xiaoming']
print(name_list)

#如果append()追加的数据是⼀个序列，则追加整个序列到列表

name_list = ['Tom', 'Lily', 'Rose']
name_list.append(['xiaoming', 'xiaohong'])
## 结果：['Tom', 'Lily', 'Rose', ['xiaoming', 'xiaohong']]
print(name_list)

extend()：列表结尾追加数据，如果数据是⼀个序列，则将这个序列的数据逐⼀添加到列表

语法

列表序列.extend(数据)

name_list = ['Tom', 'Lily', 'Rose']
name_list.extend('xiaoming')
## 结果：['Tom', 'Lily', 'Rose', 'x', 'i', 'a', 'o', 'm', 'i', 'n', 'g']
print(name_list)

name_list = ['Tom', 'Lily', 'Rose']
name_list.extend(['xiaoming', 'xiaohong'])
## 结果：['Tom', 'Lily', 'Rose', 'xiaoming', 'xiaohong']
print(name_list)

insert()：指定位置新增数据。

语法

列表序列.insert(位置下标, 数据)

name_list = ['Tom', 'Lily', 'Rose']
name_list.insert(1, 'xiaoming')
## 结果：['Tom', 'xiaoming', 'Lily', 'Rose']
print(name_list)

删除

语法

del ⽬标 

删除列表

name_list = ['Tom', 'Lily', 'Rose']
## 结果：报错提示：name 'name_list' is not defined
del name_list
print(name_list)




删除指定数据

name_list = ['Tom', 'Lily', 'Rose']
del name_list[0]
## 结果：['Lily', 'Rose']
print(name_list)

pop()：删除指定下标的数据(默认为最后⼀个)，并返回该数据

语法

列表序列.pop(下标) 


name_list = ['Tom', 'Lily', 'Rose']
del_name = name_list.pop(1)
## 结果：Lily
print(del_name)
## 结果：['Tom', 'Rose']
print(name_list)

remove()：移除列表中某个数据的第⼀个匹配项。

语法:

列表序列.remove(数据)

name_list = ['Tom', 'Lily', 'Rose']
name_list.remove('Rose')
## 结果：['Tom', 'Lily']
print(name_list)

clear()：清空列表

name_list = ['Tom', 'Lily', 'Rose']
name_list.clear()
print(name_list) ## 结果： []

修改

name_list = ['Tom', 'Lily', 'Rose']

name_list[0] = 'aaa'

## 结果：['aaa', 'Lily', 'Rose']
print(name_list)

其他语法

逆置：reverse()

num_list = [1, 5, 2, 3, 6, 8]

num_list.reverse()

## 结果：[8, 6, 3, 2, 5, 1]
print(num_list)

排序：sort()

列表序列.sort( key=None, reverse=False)

注意：reverse表示排序规则，reverse = True 降序， reverse = False 升序（默认）


num_list = [1, 5, 2, 3, 6, 8]

num_list.sort()

## 结果：[1, 2, 3, 5, 6, 8]
print(num_list)

复制 copy()

name_list = ['Tom', 'Lily', 'Rose']
name_li2 = name_list.copy()
## 结果：['Tom', 'Lily', 'Rose']
print(name_li2)

列表的循环遍历

name_list = ['Tom', 'Lily', 'Rose'] 

i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

```plain
name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
 print(i)

列表嵌套

所谓列表嵌套指的就是⼀个列表⾥⾯包含了其他的⼦列表

应⽤场景：要存储班级⼀、⼆、三三个班级学⽣姓名，且每个班级的学⽣姓名在⼀个列表

name_list = [['⼩明', '⼩红', '⼩绿'], ['Tom', 'Lily', 'Rose'], ['张三', '李四', '王五']]

元组

元组可以存储多个数据，元组内的数据是不能修改的

元组特点：定义元组使⽤⼩括号，且逗号隔开各个数据，数据可以是不同的数据类型

## 多个数据元组
t1 = (10, 20, 30)

## 单个数据元组
t2 = (10,)

注意：如果定义的元组只有⼀个数据，那么这个数据后⾯也好添加逗号，否则数据类型为唯⼀的这个数据的数据类型

t2 = (10,)
print(type(t2)) ## tuple


t3 = (20)
print(type(t3)) ## int


t4 = ('hello')
print(type(t4)) ## str

元组的常⻅操作

元组数据不⽀持修改，只⽀持查找

按下标查找数据

tuple1 = ('aa', 'bb', 'cc', 'bb')
print(tuple1[0]) ## aa

index()：查找某个数据，如果数据存在返回对应的下标，否则报错，语法和列表、字符串的index⽅法相同。

count()：统计某个数据在当前元组出现的次数。

len()：统计元组中数据的个数。

注意：元组内的直接数据如果修改则⽴即报错

但是如果元组⾥⾯有列表，修改列表⾥⾯的数据则是⽀持的，故⾃觉很重要。

集合

创建集合使⽤ {} 或 set() ， 但是如果要创建空集合只能使⽤ set() ，因为 {} ⽤来创建空字典。

s1 = {10, 20, 30, 40, 50}
print(s1)


s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2)


s3 = set('abcdefg')
print(s3)


s4 = set()
print(type(s4)) ## set


s5 = {}
print(type(s5)) ## dict

集合可以去掉重复数据；

集合数据是⽆序的，故不⽀持下标

集合常⻅操作⽅法

增加数据

add()

s1 = {10, 20}
s1.add(100)
s1.add(10)
print(s1) ## {100, 10, 20}
因为集合有去重功能，所以，当向集合内追加的数据是当前集合已有数据的话，则不进⾏任何操作

update(), 追加的数据是序列

s1 = {10, 20}
## s1.update(100) ## 报错
s1.update([100, 200])
s1.update('abc')
print(s1)

删除数据

remove()，删除集合中的指定数据，如果数据不存在则报错。

s1 = {10, 20}


s1.remove(10)
print(s1)


s1.remove(10) ## 报错
print(s1)

discard()，删除集合中的指定数据，如果数据不存在也不会报错。

s1 = {10, 20}

s1.discard(10)
print(s1)

s1.discard(10)
print(s1)

pop()，随机删除集合中的某个数据，并返回这个数据。

s1 = {10, 20, 30, 40, 50}
del_num = s1.pop()
print(del_num)
print(s1)

查找数据

  • in：判断数据在集合序列
  • not in：判断数据不在集合序列
s1 = {10, 20, 30, 40, 50}
print(10 in s1)
print(10 not in s1)

字典

创建字典的语法

字典特点：

  • 符号为⼤括号
  • 数据为键值对形式出现
  • 各个键值对之间⽤逗号隔开
## 有数据字典
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

## 空字典
dict2 = {}
dict3 = dict()

⼀般称冒号前⾯的为键(key)，简称k；冒号后⾯的为值(value)，简称v

字典常⻅操作

增

写法：字典序列[key] = 值

注意：如果key存在则修改这个key对应的值；如果key不存在则新增此键值对。

注意：字典为可变类型

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

dict1['name'] = 'Rose'
## 结果：{'name': 'Rose', 'age': 20, 'gender': '男'}
print(dict1)


dict1['id'] = 110

## {'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
print(dict1)

删

del() / del：删除字典或删除字典中指定键值对

clear()：清空字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}


del dict1['gender']
## 结果：{'name': 'Tom', 'age': 20}
print(dict1)


dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
dict1.clear()
print(dict1) ## {}

改

写法：字典序列[key] = 值

注意：如果key存在则修改这个key对应的值 ；如果key不存在则新增此键值对

查

key值查找

如果当前查找的key存在，则返回对应的值；否则则报错。

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

print(dict1['name']) ## Tom

print(dict1['id']) ## 报错

get()

注意：如果当前查找的key不存在则返回第⼆个参数(默认值)，如果省略第⼆个参数，则返回None。

字典序列.get(key, 默认值)

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name')) ## Tom
print(dict1.get('id', 110)) ## 110
print(dict1.get('id')) ## None

keys()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys()) ## dict_keys(['name', 'age', 'gender'])

values()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values()) ## dict_values(['Tom', 20, '男'])

items()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items()) ## dict_items([('name', 'Tom'), ('age', 20), ('gender','男')])

字典的循环遍历

遍历字典的key

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key in dict1.keys():
 print(key)


 遍历字典的value

 dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for value in dict1.values():
 print(value)



  遍历字典的元素
 dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
 print(item)


  遍历字典的键值对
 dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
 print(f'{key} = {value}')

公共操作

运算符

+

## 1. 字符串
str1 = 'aa'
str2 = 'bb'
str3 = str1 + str2
print(str3) ## aabb


## 2. 列表
list1 = [1, 2]
list2 = [10, 20]
list3 = list1 + list2
print(list3) ## [1, 2, 10, 20]


## 3. 元组
t1 = (1, 2)
t2 = (10, 20)
t3 = t1 + t2
print(t3) ## (10, 20, 100, 200)

*

 ## 1. 字符串
print('-' * 10) ## ----------



## 2. 列表
list1 = ['hello']
print(list1 * 4) ## ['hello', 'hello', 'hello', 'hello']


## 3. 元组
t1 = ('world',)
print(t1 * 4) ## ('world', 'world', 'world', 'world')

in或not in

## 1. 字符串
print('a' in 'abcd') ## True
print('a' not in 'abcd') ## False


## 2. 列表
list1 = ['a', 'b', 'c', 'd']
print('a' in list1) ## True
print('a' not in list1) ## False


## 3. 元组
t1 = ('a', 'b', 'c', 'd')
print('aa' in t1) ## False
print('aa' not in t1) ## True

公共⽅法

len()

## 1. 字符串
str1 = 'abcdefg'
print(len(str1)) ## 7


## 2. 列表
list1 = [10, 20, 30, 40]
print(len(list1)) ## 4


## 3. 元组
t1 = (10, 20, 30, 40, 50)
print(len(t1)) ## 5


## 4. 集合
s1 = {10, 20, 30}
print(len(s1)) ## 3

## 5. 字典
dict1 = {'name': 'Rose', 'age': 18}
print(len(dict1)) ## 2

del()

## 1. 字符串
str1 = 'abcdefg'
del str1
print(str1)


## 2. 列表
list1 = [10, 20, 30, 40]
del(list1[0])
print(list1) ## [20, 30, 40]

max()

## 1. 字符串
str1 = 'abcdefg'
print(max(str1)) ## g


## 2. 列表
list1 = [10, 20, 30, 40]
print(max(list1)) ## 40

min()

## 1. 字符串
str1 = 'abcdefg'
print(min(str1)) ## a


## 2. 列表
list1 = [10, 20, 30, 40]
print(min(list1)) ## 10

range()

## 1 2 3 4 5 6 7 8 9
for i in range(1, 10, 1):
 print(i)



## 1 3 5 7 9
for i in range(1, 10, 2):
 print(i)



## 0 1 2 3 4 5 6 7 8 9
for i in range(10):
 print(i)

 range()⽣成的序列不包含end数字

enumerate()

语法

enumerate(可遍历对象, start=0)

```plain
list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1):
 print(i)


for index, char in enumerate(list1, start=1):
 print(f'下标是{index}, 对应的字符是{char}')

tuple()

将某个序列转换成元组

list1 = [10, 20, 30, 40, 50, 20]
s1 = {100, 200, 300, 400, 500}


print(tuple(list1))
print(tuple(s1))

list()

将某个序列转换成列表

t1 = ('a', 'b', 'c', 'd', 'e')
s1 = {100, 200, 300, 400, 500}


print(list(t1))
print(list(s1))

set()

将某个序列转换成集合

list1 = [10, 20, 30, 40, 50, 20]
t1 = ('a', 'b', 'c', 'd', 'e')


print(set(list1))
print(set(t1))


1. 集合可以快速完成列表去重
2. 集合不⽀持下标

推导式

作⽤：⽤⼀个表达式创建⼀个有规律的列表或控制⼀个有规律列表。列表推导式⼜叫列表⽣成式

列表推导式

需求：创建⼀个0-10的列表。

while循环实现
## 1. 准备⼀个空列表
list1 = []
## 2. 书写循环，依次追加数字到空列表list1中 i = 0
while i < 10:
    list1.append(i)
    i += 1
print(list1)
for循环实现
list1 = []
for i in range(10):
    list1.append(i)
print(list1)
列表推导式实现
list1 = [i for i in range(10)]
print(list1)

带if的列表推导式

需求：创建0-10的偶数列表

⽅法⼀：range()步⻓实现
list1 = [i for i in range(0, 10, 2)]
print(list1)
⽅法⼆：if实现
list1 = [i for i in range(10) if i % 2 == 0]

print(list1)

多个for循环实现列表推导式

需求：创建列表如下：

[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

代码如下:

list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)

字典推导式

思考：如果有如下两个列表：

list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']

如何快速合并为⼀个字典？

答：字典推导式

字典推导式作⽤：快速合并列表为字典或提取字典中⽬标数据

1.创建⼀个字典：字典key是1-5数字，value是这个数字的2次⽅。

dict1 = {i: i**2 for i in range(1, 5)}
print(dict1) ## {1: 1, 2: 4, 3: 9, 4: 16}

2.将两个列表合并为⼀个字典

list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']

dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)

3.提取字典中⽬标数据

counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}


## 需求：提取上述电脑数量⼤于等于200的字典数据
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1) ## {'MBP': 268, 'DELL': 201}

集合推导式

创建⼀个集合，数据为下⽅列表的2次⽅。

list1 = [1, 1, 2]

```plain
list1 = [1, 1, 2]
set1 = {i ** 2 for i in list1}
print(set1) ## {1, 4}

注意：集合有数据去重功能

总结

## 列表推导式
[xx for xx in range()]


## 字典推导式
{xx1: xx2 for ... in ...}


## 集合推导式
{xx for xx in ...}

函数

定义函数

def 函数名(参数):
""" 说明⽂档的位置 """
 代码1
 代码2
 return  any
 ......

调⽤函数

函数名(参数)

查看函数帮助

def sum_num(a, b):
 """ 求和函数 """
 return a + b



help(sum_num)

变量作⽤域

变量作⽤域指的是变量⽣效的范围，主要分为两类：局部变量和全局变量

局部变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部⽣效

def testA():
 a = 100

 print(a)


testA() ## 100
print(a) ## 报错：name 'a' is not defined

变量a是定义在 testA 函数内部的变量，在函数外部访问则⽴即报错。

局部变量的作⽤：在函数体内部，临时保存数据，即当函数调⽤完成后，则销毁局部变量

全局变量

所谓全局变量，指的是在函数体内、外都能⽣效的变量。

思考：如果有⼀个数据，在函数A和函数B中都要使⽤，该怎么办？

答：将这个数据存储在⼀个全局变量⾥⾯。

## 定义全局变量a a = 100
def testA():

print(a) ## 访问全局变量a，并打印变量a存储的数据


def testB():


 print(a) ## 访问全局变量a，并打印变量a存储的数据

testA() ## 100
testB() ## 100

函数的参数

位置参数

位置参数：调⽤函数时根据函数定义的参数位置来传递参数

def user_info(name, age, gender):

 print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')

user_info('TOM', 20, '男')

传递和定义参数的顺序及个数必须⼀致。

关键字参数

函数调⽤，通过“键=值”形式加以指定。可以让函数更加清晰、容易使⽤，同时也清除了参数的顺序需求。

def user_info(name, age, gender):

 print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')

user_info('Rose', age=20, gender='⼥')

user_info('⼩明', gender='男', age=16)
缺省参数

缺省参数也叫默认参数，⽤于定义函数，为参数提供默认值，调⽤函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调⽤）

def user_info(name, age, gender='男'):
    print(f'您的名字是{name}, 年龄是{age}, 性别是{gender}')


user_info('TOM', 20)
user_info('Rose', 18, '⼥')

函数调⽤时，如果为缺省参数传值则修改默认参数值；否则使⽤这个默认值。

不定⻓参数

不定⻓参数也叫可变参数。⽤于不确定调⽤的时候会传递多少个参数(不传参也可以)的场景。此时，可⽤包裹(packing)位置参数，或者包裹关键字参数，来进⾏参数传递，会显得⾮常⽅便。

包裹位置传递
def user_info(*args):
 print(args)


## ('TOM',)
user_info('TOM')
## ('TOM', 18)
user_info('TOM', 18)

注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为⼀个元组(tuple)，args是元组类型，这就是包裹位置传递。

包裹关键字传递

⽆论是包裹位置传递还是包裹关键字传递，都是⼀个组包的过程

def user_info(**kwargs):
 print(kwargs)


## {'name': 'TOM', 'age': 18, 'id': 110}
user_info(name='TOM', age=18, id=110)

拆包和交换变量值

拆包
def return_num():
 return 100, 200
num1, num2 = return_num()
print(num1) ## 100
print(num2) ## 200
拆包：字典
dict1 = {'name': 'TOM', 'age': 18} a, b = dict1
## 对字典进⾏拆包，取出来的是字典的key

print(a) ## name
print(b) ## age

print(dict1[a]) ## TOM
print(dict1[b]) ## 18
交换变量值
a, b = 1, 2 
a, b = b, a
print(a) ## 2
print(b) ## 1

引⽤

在python中，值是靠引⽤来传递来的。

我们可以⽤ id()

id() 来判断两个变量是否为同⼀个值的引⽤。 我们可以将id值理解为那块内存的地址标识

## 1. int类型
a = 1 
b = a

print(b) ## 1
print(id(a)) ## 140708464157520
print(id(b)) ## 140708464157520

a = 2

print(b) ## 1,说明int类型为不可变类型

print(id(a)) ## 140708464157552，此时得到是的数据2的内存地址
print(id(b)) ## 140708464157520


## 2. 列表
aa = [10, 20]
bb = aa
print(id(aa)) ## 2325297783432
print(id(bb)) ## 2325297783432
aa.append(30)


print(bb) ## [10, 20, 30], 列表为可变类型
print(id(aa)) ## 2325297783432
print(id(bb)) ## 2325297783432

引⽤当做实参

def test1(a):
    print(a)
    print(id(a))
    a += a
    print(a)
    print(id(a))
## int：计算前后id值不同
b = 100
test1(b)
## 列表：计算前后id值相同
c = [11, 22]
test1(c)

可变和不可变类型

所谓可变类型与不可变类型是指：数据能够直接进⾏修改，如果能直接修改那么就是可变，否则是不可变.

可变类型

  • 列表
  • 字典
  • 集合

不可变类型

  • 整型
  • 浮点型
  • 字符串
  • 元组

lambda

lambda 参数列表 ： 表达式

lambda表达式的参数可有可⽆，函数的参数在lambda表达式中完全适⽤。

lambda函数能接收任何数量的参数但只能返回⼀个表达式的值

## 函数
def fn1():
 return 200
print(fn1)
print(fn1())

## lambda表达式
fn2 = lambda: 100
print(fn2)
print(fn2())

直接打印lambda表达式，输出的是此lambda的内存地址

计算a + b

函数实现

def add(a, b):
    return a + b
result = add(1, 2)
print(result)

lambda实现

print((lambda a, b: a + b)(1, 2))

lambda的参数形式

⽆参数

print((lambda: 100)())

⼀个参数

print((lambda a: a)('hello world'))

默认参数

print((lambda a, b, c=100: a + b + c)(10, 20))

**可变参数：*args

print((lambda *args: args)(10, 20, 30))

**可变参数：*kwargs

print((lambda **kwargs: kwargs)(name='python', age=20))

lambda的应⽤

带判断的lambda

print((lambda a, b: a if a > b else b)(1000, 500))

列表数据按字典key的值排序

students = [
 {'name': 'TOM', 'age': 20},
 {'name': 'ROSE', 'age': 19},
 {'name': 'Jack', 'age': 22}]
## 按name值升序排列
students.sort(key=lambda x: x['name'])
print(students)
## 按name值降序排列
students.sort(key=lambda x: x['name'], reverse=True)
print(students)
## 按age值升序排列
students.sort(key=lambda x: x['age'])
print(students)

⾼阶函数

把函数作为参数传⼊，这样的函数称为⾼阶函数，⾼阶函数是函数式编程的体现。函数式编程就是指这种⾼度抽象的编程范式

abs() 函数可以完成对数字求绝对值计算

需求：⼀个函数完成计算任意两个数字的绝对值之和。

方法1:

def add_num(a, b):
    return abs(a) + abs(b)
result = add_num(-1, 2)
print(result) ## 3

方法2:

def sum_num(a, b, f):
    return f(a) + f(b)
result = sum_num(-1, 2, abs)
print(result) ## 3

两种⽅法对⽐之后，发现，⽅法2的代码会更加简洁

内置⾼阶函数

map()

map(func, lst)，将传⼊的函数变量func作⽤到lst变量的每个元素中，并将结果组成新的列表(Python2)/迭代器(Python3)返回。

需求：计算 list1 序列中各个数字的2次⽅

list1 = [1, 2, 3, 4, 5]

def func(x):
    return x ** 2

result = map(func, list1)

print(result) ## <map object at 0x0000013769653198>
print(list(result)) ## [1, 4, 9, 16, 25]

reduce()

reduce(func(x,y)，lst)，其中func必须有两个参数。每次func计算的结果继续和序列的下⼀个元素做累积计算

需求：计算 list1 序列中各个数字的累加和。

import functools

list1 = [1, 2, 3, 4, 5]


def func(a, b):
    return a + b


result = functools.reduce(func, list1)
print(result) ## 15

filter()

filter(func, lst)函数⽤于过滤序列, 过滤掉不符合条件的元素, 返回⼀个 fifilter 对象,。如果要转换为列表,可以使⽤ list() 来转换。

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def func(x):
    return x % 2 == 0

result = filter(func, list1)
print(result) ## <filter object at 0x0000017AF9DC3198>
print(list(result)) ## [2, 4, 6, 8, 10]

⽂件的基本操作

打开⽂件

open(name, mode)

name：是要打开的⽬标⽂件名的字符串(可以包含⽂件所在的具体路径)。
mode：设置打开⽂件的模式(访问模式)：只读、写⼊、追加等。



file = open('test.txt', 'w+')

写

对象对象.write('内容')


## 1. 打开⽂件
f = open('test.txt', 'w')
## 2.⽂件写⼊
f.write('hello world')
## 3. 关闭⽂件
f.close()

读

read()

⽂件对象.read(num)

num表示要从⽂件中读取的数据的⻓度（单位是字节），如果没有传⼊num，那么就表示读取⽂件中所有的数据。

readlines()

readlines()
readline()

readlines可以按照⾏的⽅式把整个⽂件中的内容进⾏⼀次性读取，并且返回的是⼀个列表，其中每⼀⾏的数据为⼀个元素。
readline⼀次读取⼀⾏内容

```python

f = open('test.txt')
content = f.readlines()
## ['hello world
', 'abcdefg
', 'aaa
', 'bbb
', 'ccc']
print(content)
## 关闭⽂件
f.close()

seek()

⽂件对象.seek(偏移量, 起始位置)
起始位置:
0：⽂件开头
1：当前位置
2：⽂件结尾

关闭

⽂件对象.close()

⽂件备份

需求：⽤户输⼊当前⽬录下任意⽂件名，程序完成对该⽂件的备份功能(备份⽂件名为xx[备份]后缀，例如：test[备份].txt)

  1. 接收⽤户输⼊的⽂件名
  2. 规划备份⽂件名
  3. 备份⽂件写⼊数据
old_name = input('请输⼊您要备份的⽂件完整路径(包含文件名和后缀)：')

rfind_index = old_name.rfind(".")

newName = old_name[:rfind_index] + "[备份]" + old_name[rfind_index:]

print("新文件:" + newName)

oldFile = open(old_name, "rb")
newFile = open(newName, "wb")

while True:
    con = oldFile.read(1024)
    if len(con) == 0:
        break
    newFile.write(con)

oldFile.close()
newFile.close()

⽂件和⽂件夹的操作

在Python中⽂件和⽂件夹的操作要借助os模块⾥⾯的相关功能，具体步骤如下：

1. 导⼊os模块
import os

2. 使⽤ os 模块相关功能
os.函数名()

⽂件重命名

os.rename(⽬标⽂件名, 新⽂件名)

删除文件

os.remove(⽬标⽂件名)

创建文件夹

os.mkdir(⽂件夹名字)

删除文件夹

os.rmdir(⽂件夹名字)

获取当前目录

os.getcwd()

改变默认目录

os.chdir(⽬录)

获取目录列表

os.listdir(⽬录)

⾯向对象基础

定义类

语法

class 类名():
 代码
 ......

：类名要满⾜标识符命名规则，同时遵循⼤驼峰命名习惯

class Washer():
    def wash(self):
        print('我会洗⾐服')

创建对象

对象名 = 类名()

```python

## 创建对象
haier1 = Washer()
## <__main__.Washer object at 0x0000018B7B224240>
print(haier1)
## haier对象调⽤实例⽅法
haier1.wash()

self

self指的是调⽤该函数的对象

## 1. 定义类
class Washer():
 def wash(self):
    print('我会洗⾐服')
    ## <__main__.Washer object at 0x0000024BA2B34240>
    print(self)
## 2. 创建对象
haier1 = Washer()
## <__main__.Washer object at 0x0000018B7B224240>
print(haier1)
## haier1对象调⽤实例⽅法


haier1.wash()
haier2 = Washer()
## <__main__.Washer object at 0x0000022005857EF0>
print(haier2)

添加和获取对象属性

属性即是特征，⽐如：洗⾐机的宽度、⾼度、重量…
对象属性既可以在类外⾯添加和获取，也能在类⾥⾯添加和获取

类外⾯添加对象属性
对象名.属性名 = 值

haier1.width = 500
haier1.height = 800
类外⾯获取对象属性
对象名.属性名

print(f'haier1洗⾐机的宽度是{haier1.width}')
print(f'haier1洗⾐机的⾼度是{haier1.height}')
类⾥⾯获取对象属性
self.属性名


## 定义类
class Washer():
    def print_info(self):
        ## 类⾥⾯获取实例属性
        print(f'haier1洗⾐机的宽度是{self.width}')
        print(f'haier1洗⾐机的⾼度是{self.height}')


## 创建对象
haier1 = Washer()


## 添加实例属性
haier1.width = 500
haier1.height = 800
haier1.print_info()

魔法⽅法

在Python中， xx() 的函数叫做魔法⽅法，指的是具有特殊功能的函数

init()

init() ⽅法的作⽤：初始化对象。

class Washer():

 ## 定义初始化功能的函数
 def __init__(self):
    ## 添加实例属性
    self.width = 500
    self.height = 800

 def print_info(self):
    ## 类⾥⾯调⽤实例属性
    print(f'洗⾐机的宽度是{self.width}, ⾼度是{self.height}')


haier1 = Washer()
haier1.print_info()

init() ⽅法，在创建⼀个对象时默认被调⽤，不需要⼿动调⽤
init(self) 中的self参数，不需要开发者传递，python解释器会⾃动把当前的对象引⽤传递过去。

带参数的  init()

⼀个类可以创建多个对象，如何对不同的对象设置不同的初始化属性呢？ 答：传参数。

class Washer():
 def __init__(self, width, height):
    self.width = width
    self.height = height
 def print_info(self):
    print(f'洗⾐机的宽度是{self.width}')
    print(f'洗⾐机的⾼度是{self.height}')
haier1 = Washer(10, 20)
haier1.print_info()
haier2 = Washer(30, 40)
haier2.print_info()
str()

当使⽤print输出对象的时候，默认打印对象的内存地址。如果类定义了 str ⽅法，那么就会打印从 在这个⽅法中 return 的数据。

class Washer():
 def __init__(self, width, height):
    self.width = width
    self.height = height
 def __str__(self):
    return '这是海尔洗⾐机的说明书'
haier1 = Washer(10, 20)
## 这是海尔洗⾐机的说明书
print(haier1)
del()

当删除对象时，python解释器也会默认调⽤ del() ⽅法。

class Washer():
 def __init__(self, width, height):
    self.width = width
    self.height = height
 def __del__(self):
    print(f'{self}对象已经被删除')
haier1 = Washer(10, 20)
## <__main__.Washer object at 0x0000026118223278>对象已经被删除
del haier1

⾯向对象-继承

不由任意内置类型派⽣出的类，称之为经典类

拓展1：经典类或旧式类

class 类名:
 代码
 ......

拓展2：新式类

class 类名(object):
 代码

Python⾯向对象的继承指的是多个类之间的所属关系，即⼦类默认继承⽗类的所有属性和⽅法，具体如 下：

## ⽗类A
class A(object):
    def __init__(self):
        self.num = 1
    def info_print(self):
        print(self.num)
## ⼦类B
class B(A):
    pass

result = B()
result.info_print() ## 1

在Python中，所有类默认继承object类，object类是顶级类或基类；其他⼦类叫做派⽣类

单继承

故事主线：⼀个煎饼果⼦⽼师傅，在煎饼果⼦界摸爬滚打多年，研发了⼀套精湛的摊煎饼果⼦的 技术。师⽗要把这套技术传授给他的唯⼀的最得意的徒弟。

分析：徒弟是不是要继承师⽗的所有技术？

## 1. 师⽗类
class Master(object):
 def __init__(self):
    self.kongfu = '[古法煎饼果⼦配⽅]'
 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')

## 2. 徒弟类
class Prentice(Master):
 pass
## 3. 创建对象daqiu
daqiu = Prentice()
## 4. 对象访问实例属性
print(daqiu.kongfu)

## 5. 对象调⽤实例⽅法
daqiu.make_cake()

多继承

故事推进：daqiu是个爱学习的好孩⼦，想学习更多的煎饼果⼦技术，于是，在百度搜索到⿊⻢程 序员，报班学习煎饼果⼦技术。

所谓多继承意思就是⼀个类同时继承了多个⽗类

class Master(object):
 def __init__(self):
    self.kongfu = '[古法煎饼果⼦配⽅]'
    def make_cake(self):
        print(f'运⽤{self.kongfu}制作煎饼果⼦')
## 创建学校类
class School(object):
 def __init__(self):
    self.kongfu = '[⿊⻢煎饼果⼦配⽅]'
 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')
class Prentice(School, Master):
 pass
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

⼦类重写⽗类同名⽅法和属性

故事：daqiu掌握了师⽗和培训的技术后，⾃⼰潜⼼钻研出⾃⼰的独⻔配⽅的⼀套全新的煎饼果⼦技术。

class Master(object):
 def __init__(self):
    self.kongfu = '[古法煎饼果⼦配⽅]'

 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')



class School(object):
 def __init__(self):
    self.kongfu = '[⿊⻢煎饼果⼦配⽅]'
 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')



## 独创配⽅
class Prentice(School, Master):
 def __init__(self):
    self.kongfu = '[独创煎饼果⼦配⽅]'
 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')




daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
print(Prentice.__mro__)

⼦类和⽗类具有同名属性和⽅法，默认使⽤⼦类的同名属性和⽅法

⼦类调⽤⽗类的同名⽅法和属性

故事：很多顾客都希望也能吃到古法和⿊⻢的技术的煎饼果⼦。

class Master(object):
 def __init__(self):
    self.kongfu = '[古法煎饼果⼦配⽅]'
 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')

class School(object):
 def __init__(self):
    self.kongfu = '[⿊⻢煎饼果⼦配⽅]'


 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Prentice(School, Master):
 def __init__(self):
    self.kongfu = '[独创煎饼果⼦配⽅]'
 def make_cake(self):
    ## 如果是先调⽤了⽗类的属性和⽅法，⽗类属性会覆盖⼦类属性，故在调⽤属性前，先调⽤⾃⼰⼦类的初始化
    self.__init__()
    print(f'运⽤{self.kongfu}制作煎饼果⼦')
    ## 调⽤⽗类⽅法，但是为保证调⽤到的也是⽗类的属性，必须在调⽤⽅法前调⽤⽗类的初始化
 def make_master_cake(self):
    Master.__init__(self)
    Master.make_cake(self)
 def make_school_cake(self):
    School.__init__(self)
    School.make_cake(self)


daqiu = Prentice()
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()
daqiu.make_cake()

多层继承

故事：N年后，daqiu⽼了，想要把所有技术传承给⾃⼰的徒弟

class Master(object):
 def __init__(self):
    self.kongfu = '[古法煎饼果⼦配⽅]'
 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')

class School(object):
 def __init__(self):
    self.kongfu = '[⿊⻢煎饼果⼦配⽅]'
 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')
class Prentice(School, Master):
 def __init__(self):
    self.kongfu = '[独创煎饼果⼦配⽅]'
 def make_cake(self):
    self.__init__()
    print(f'运⽤{self.kongfu}制作煎饼果⼦')
 def make_master_cake(self):
    Master.__init__(self)
    Master.make_cake(self)
 def make_school_cake(self):
    School.__init__(self)
    School.make_cake(self)
## 徒孙类
class Tusun(Prentice):
 pass
xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.make_school_cake()
xiaoqiu.make_master_cake()

super()调⽤⽗类⽅法

class Master(object):
 def __init__(self):
    self.kongfu = '[古法煎饼果⼦配⽅]'



def make_cake(self):
 print(f'运⽤{self.kongfu}制作煎饼果⼦')
class School(Master):
 def __init__(self):
    self.kongfu = '[⿊⻢煎饼果⼦配⽅]'
 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')
    ## ⽅法2.1
    ## super(School, self).__init__()
    ## super(School, self).make_cake()
    ## ⽅法2.2
    super().__init__()
    super().make_cake()
class Prentice(School):
 def __init__(self):
    self.kongfu = '[独创煎饼果⼦技术]'
 def make_cake(self):
    self.__init__()
    print(f'运⽤{self.kongfu}制作煎饼果⼦')
    ## ⼦类调⽤⽗类的同名⽅法和属性：把⽗类的同名属性和⽅法再次封装
 def make_master_cake(self):
    Master.__init__(self)
    Master.make_cake(self)
 def make_school_cake(self):
    School.__init__(self)
    School.make_cake(self)
    ## ⼀次性调⽤⽗类的同名属性和⽅法
 def make_old_cake(self):
    ## ⽅法⼀：代码冗余；⽗类类名如果变化，这⾥代码需要频繁修改
    ## Master.__init__(self)
    ## Master.make_cake(self)
    ## School.__init__(self)
    ## School.make_cake(self)
    ## ⽅法⼆: super()
    ## ⽅法2.1 super(当前类名, self).函数()
    ## super(Prentice, self).__init__()
    ## super(Prentice, self).make_cake()

    ## ⽅法2.2 super().函数()
    super().__init__()
    super().make_cake()

daqiu = Prentice()
daqiu.make_old_cake()

使⽤super() 可以⾃动查找⽗类。调⽤顺序遵循 mro 类属性的顺序。⽐较适合单继承使⽤。

私有权限

定义私有属性和⽅法

在Python中，可以为实例属性和⽅法设置私有权限，即设置某个实例属性或实例⽅法不继承给⼦类。

故事：daqiu把技术传承给徒弟的同时，不想把⾃⼰的钱(2000000个亿)继承给徒弟，这个时候就 要为 钱 这个实例属性设置私有权限。

设置私有权限的⽅法：在属性名和⽅法名 前⾯ 加上两个下划线 __。

class Master(object):
 def __init__(self):
    self.kongfu = '[古法煎饼果⼦配⽅]'
 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')
class School(object):
 def __init__(self):
    self.kongfu = '[⿊⻢煎饼果⼦配⽅]'
 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')


class Prentice(School, Master):
 def __init__(self):
    self.kongfu = '[独创煎饼果⼦配⽅]'
    ## 定义私有属性
    self.__money = 2000000


    ## 定义私有⽅法
 def __info_print(self):
    print(self.kongfu)
    print(self.__money)
 def make_cake(self):
    self.__init__()
    print(f'运⽤{self.kongfu}制作煎饼果⼦')
 def make_master_cake(self):
    Master.__init__(self)
    Master.make_cake(self)
 def make_school_cake(self):
    School.__init__(self)
    School.make_cake(self)



## 徒孙类
class Tusun(Prentice):
 pass
daqiu = Prentice()
## 对象不能访问私有属性和私有⽅法
## print(daqiu.__money)
## daqiu.__info_print()
xiaoqiu = Tusun()
## ⼦类⽆法继承⽗类的私有属性和私有⽅法
## print(xiaoqiu.__money) ## ⽆法访问实例属性__money
## xiaoqiu.__info_print()

注意：私有属性和私有⽅法只能在类⾥⾯访问和修改

获取和修改私有属性值

在Python中，⼀般定义函数名 get_xx ⽤来获取私有属性，定义 set_xx ⽤来修改私有属性值。

class Master(object):
 def __init__(self):
    self.kongfu = '[古法煎饼果⼦配⽅]'
 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')
class School(object):
def __init__(self):
    self.kongfu = '[⿊⻢煎饼果⼦配⽅]'
 def make_cake(self):
    print(f'运⽤{self.kongfu}制作煎饼果⼦')
class Prentice(School, Master):
 def __init__(self):
    self.kongfu = '[独创煎饼果⼦配⽅]'
    self.__money = 2000000
    ## 获取私有属性
 def get_money(self):
    return self.__money
 ## 修改私有属性
 def set_money(self):
    self.__money = 500
 def __info_print(self):
    print(self.kongfu)
    print(self.__money)
 def make_cake(self):
    self.__init__()
    print(f'运⽤{self.kongfu}制作煎饼果⼦')
 def make_master_cake(self):
    Master.__init__(self)
    Master.make_cake(self)
 def make_school_cake(self):
    School.__init__(self)
    School.make_cake(self)
## 徒孙类
class Tusun(Prentice):
 pass
daqiu = Prentice()
xiaoqiu = Tusun()
## 调⽤get_money函数获取私有属性money的值
print(xiaoqiu.get_money())
## 调⽤set_money函数修改私有属性money的值
xiaoqiu.set_money()

print(xiaoqiu.get_money())

面向对象 其他

封装
将属性和⽅法书写到类的⾥⾯的操作即为封装
封装可以为属性和⽅法添加私有权限
继承
⼦类默认继承⽗类的所有属性和⽅法
⼦类可以重写⽗类属性和⽅法
多态
传⼊不同的对象，产⽣不同的结果

多态

多态指的是⼀类事物有多种形态，（⼀个抽象类有多个⼦类，因⽽多态的概念依赖于继承）。

定义：多态是⼀种使⽤对象的⽅式，⼦类重写⽗类⽅法，调⽤不同⼦类对象的相同⽗类⽅法，可以产⽣不同的执⾏结果
好处：调⽤灵活，有了多态，更容易编写出通⽤的代码，做出通⽤的编程，以适应需求的不断变化！
实现步骤：
定义⽗类，并提供公共⽅法
定义⼦类，并重写⽗类⽅法
传递⼦类对象给调⽤者，可以看到不同⼦类执⾏效果不同

class Dog(object):
 def work(self): ## ⽗类提供统⼀的⽅法，哪怕是空⽅法
    print('指哪打哪...')


class ArmyDog(Dog): ## 继承Dog类
    def work(self): ## ⼦类重写⽗类同名⽅法
     print('追击敌⼈...')


class DrugDog(Dog):
 def work(self):
    print('追查毒品...')


class Person(object):
 def work_with_dog(self, dog): ## 传⼊不同的对象，执⾏不同的代码，即不同的work函数
    dog.work()



ad = ArmyDog()
dd = DrugDog()
daqiu = Person()
daqiu.work_with_dog(ad)
daqiu.work_with_dog(dd)

类属性和实例属性

类属性

设置和访问类属性
类属性就是 类对象 所拥有的属性，它被 该类的所有实例对象 所共有。
类属性可以使⽤ 类对象 或 实例对象 访问。

class Dog(object):
     tooth = 10
wangcai = Dog()
xiaohei = Dog()
print(Dog.tooth) ## 10
print(wangcai.tooth) ## 10
print(xiaohei.tooth) ## 10

类属性的优点
类的实例 记录的某项数据 始终保持⼀致时，则定义类属性。
实例属性 要求 每个对象 为其 单独开辟⼀份内存空间 来记录数据，⽽ 类属性 为全类所共有 ，仅占⽤⼀份内存，更加节省内存空间。

修改类属性
class Dog(object):
    tooth = 10


wangcai = Dog()
xiaohei = Dog()
## 修改类属性
Dog.tooth = 12
print(Dog.tooth) ## 12
print(wangcai.tooth) ## 12
print(xiaohei.tooth) ## 12
## 不能通过对象修改属性，如果这样操作，实则是创建了⼀个实例属性
wangcai.tooth = 20
print(Dog.tooth) ## 12
print(wangcai.tooth) ## 20
print(xiaohei.tooth) ## 12
实例属性
class Dog(object):
 def __init__(self):
    self.age = 5
 def info_print(self):
    print(self.age)

wangcai = Dog()
print(wangcai.age) ## 5
## print(Dog.age) ## 报错：实例属性不能通过类访问
wangcai.info_print() ## 5

类⽅法和静态⽅法

类⽅法

类⽅法特点

第⼀个形参是类对象的⽅法
需要⽤装饰器 @classmethod 来标识其为类⽅法，对于类⽅法，第⼀个参数必须是类对象，⼀般以 cls 作为第⼀个参数

类⽅法使⽤场景

当⽅法中 需要使⽤类对象 (如访问私有类属性等)时，定义类⽅法
类⽅法⼀般和类属性配合使⽤

class Dog(object):
 __tooth = 10
 @classmethod
 def get_tooth(cls):
    return cls.__tooth

wangcai = Dog()
result = wangcai.get_tooth()
print(result) ## 10

静态⽅法

静态⽅法特点

需要通过装饰器 @staticmethod 来进⾏修饰，静态⽅法既不需要传递类对象也不需要传递实例对象
（形参没有self/cls）。
静态⽅法 也能够通过 实例对象 和 类对象 去访问。

静态⽅法使⽤场景

当⽅法中 既不需要使⽤实例对象(如实例对象，实例属性)，也不需要使⽤类对象 (如类属性、类⽅ 法、创建实例等)时，定义静态⽅法
取消不需要的参数传递，有利于 减少不必要的内存占⽤和性能消耗

class Dog(object):
 @staticmethod
 def info_print():
    print('这是⼀个狗类，⽤于创建狗实例....')
wangcai = Dog()
## 静态⽅法既可以使⽤对象访问⼜可以使⽤类访问
wangcai.info_print()
Dog.info_print()

异常

当检测到⼀个错误时，解释器就⽆法继续执⾏了，反⽽出现了⼀些错误的提示，这就是所谓的"异常”。
例如：以 r ⽅式打开⼀个不存在的⽂件。

open('test.txt', 'r')

语法

try:
 可能发⽣错误的代码
except:
 如果出现异常执⾏的代码

捕获多个指定异常

try:
 print(1/0)
except (NameError, ZeroDivisionError):
 print('有错误')

捕获异常描述信息

try:
 print(num)
except (NameError, ZeroDivisionError) as result:
 print(result)

捕获所有异常

try:
 print(num)
except Exception as result:
 print(result)

异常的else

else表示的是如果没有异常要执⾏的代码

try:
 print(1)
except Exception as result:
 print(result)
else:
 print('我是else，是没有异常的时候执⾏的代码')

异常的finally

finally表示的是⽆论是否异常都要执⾏的代码，例如关闭⽂件

try:
 f = open('test.txt', 'r')
except Exception as result:
 f = open('test.txt', 'w')
else:
 print('没有异常，真开⼼')
finally:
 f.close()

异常的传递

需求：

  1. 尝试只读⽅式打开test.txt⽂件，如果⽂件存在则读取⽂件内容，⽂件不存在则提示⽤户即可。
  2. 读取内容要求：尝试循环读取内容，读取过程中如果检测到⽤户意外终⽌程序，则 except 捕获异常 并提示⽤户。
import time
try:
        f = open('test.txt')
        try:
         while True:
            content = f.readline()
            if len(content) == 0:
                break
                time.sleep(2)
                print(content)
        except:
                ## 如果在读取⽂件的过程中，产⽣了异常，那么就会捕获到
                ## ⽐如 按下了 ctrl+c
                print('意外终⽌了读取数据')
        finally:
                f.close()
                print('关闭⽂件')
except:
    print("没有这个⽂件")

⾃定义异常

在Python中，抛出⾃定义异常的语法为 raise 异常类对象 。
需求：密码⻓度不⾜，则报异常（⽤户输⼊密码，如果输⼊的⻓度不⾜3位，则报错，即抛出⾃定义异 常，并捕获该异常）。

## ⾃定义异常类，继承Exception
class ShortInputError(Exception):
    def __init__(self, length, min_len):

        self.length = length
        self.min_len = min_len

    ## 设置抛出异常的描述信息
    def __str__(self):

        return f'你输⼊的⻓度是{self.length}, 不能少于{self.min_len}个字符'


def main():
    try:
        con = input('请输⼊密码：')
        if len(con) < 3:
            raise ShortInputError(len(con), 3)
    except Exception as result:
        print(result)
    else:
        print('密码已经输⼊完成')


main()

总结

异常语法

try:
 可能发⽣异常的代码
except:
 如果出现异常执⾏的代码
else:
 没有异常执⾏的代码
finally:
 ⽆论是否异常都要执⾏的代码

捕获异常

except 异常类型:
 代码
except 异常类型 as xx:
 代码

⾃定义异常

## 1. ⾃定义异常类
class 异常类类名(Exception):
 代码

## 设置抛出异常的描述信息
def __str__(self):
    return ...






## 2. 抛出异常
raise 异常类名()



## 捕获异常
except Exception....

模块和包

导⼊模块

import 模块名
from 模块名 import 功能名
from 模块名 import *
import 模块名 as 别名
from 模块名 import 功能名 as 别名

import

语法

## 1. 导⼊模块
import 模块名
import 模块名1, 模块名2...
## 2. 调⽤功能
模块名.功能名()



import math
print(math.sqrt(9)) ## 3.0

from..import..

from 模块名 import 功能1, 功能2, 功能3

...

from math import sqrt

print(sqrt(9))

from .. import *

from 模块名 import *

from math import *

print(sqrt(9))

as定义别名

## 模块定义别名
import 模块名 as 别名
## 功能定义别名
from 模块名 import 功能 as 别名

## 模块别名
import time as tt
tt.sleep(2)
print('hello')
## 功能别名
from time import sleep as sl
sl(2)
print('hello')

制作模块

在Python中，每个Python⽂件都可以作为⼀个模块，模块的名字就是⽂件的名字。也就是说⾃定义模块名必须要符合标识符命名规则。

定义模块

新建⼀个Python⽂件，命名为 my_module1.py ，并定义 testA 函数

def testA(a, b):
 print(a + b)

测试模块

在实际开中，当⼀个开发⼈员编写完⼀个模块后，为了让模块能够在项⽬中达到想要的效果，这个开发
⼈员会⾃⾏在py⽂件中添加⼀些测试信息.，例如，在 my_module1.py ⽂件中添加测试代码

def testA(a, b):
 print(a + b)
testA(1, 1)

此时，⽆论是当前⽂件，还是其他已经导⼊了该模块的⽂件，在运⾏的时候都会⾃动执⾏ testA 函数的
调⽤。
解决办法如下：

def testA(a, b):
 print(a + b)
## 只在当前⽂件中调⽤该函数，其他导⼊的⽂件内不符合该条件，则不执⾏testA函数调⽤
if __name__ == '__main__':
 testA(1, 1)

调⽤模块

import my_module1
my_module1.testA(1, 1)

all

如果⼀个模块⽂件中有 all 变量，当使⽤ from xxx import * 导⼊时，只能导⼊这个列表中的元 素。

my_module1模块代码

__all__ = ['testA']


def testA():
 print('testA')


def testB():
 print('testB')

导⼊模块的⽂件代码

from my_module1 import *

testA()
testB()

包

包将有联系的模块组织在⼀起，即放到同⼀个⽂件夹下，并且在这个⽂件夹创建⼀个名字
为 init.py ⽂件，那么这个⽂件夹就称之为包。

制作包

[New] — [Python Package] — 输⼊包名 — [OK] — 新建功能模块(有联系的模块)。
注意：新建包后，包内部会⾃动创建 init.py ⽂件，这个⽂件控制着包的导⼊⾏为。

  1. 新建包 mypackage
  2. 新建包内模块： my_module1 和 my_module2
  3. 模块内代码如下
## my_module1
print(1)
def info_print1():
 print('my_module1')



 ## my_module2
print(2)
def info_print2():
 print('my_module2')

导⼊包

⽅法⼀

import 包名.模块名
包名.模块名.⽬标



import my_package.my_module1
my_package.my_module1.info_print1()

⽅法⼆

注意：必须在 init.py ⽂件中添加 all = [] ，控制允许导⼊的模块列表。

from 包名 import *
模块名.⽬标


from my_package import *
my_module1.info_print1()

all = [] ：允许导⼊的模块或功能列表