变量与数据类型

变量

变量可⽤变量名访问，通常是可变的

Caution

变量在使⽤之前必须赋予初始值

a = 10#10这个数据在存储器中，把10的地址赋值给a
a + 20
#给a重新赋值
a = 11
a + 20

变量命名格式

1.给⼀个变量赋值 变量名=值

例：x = 10

2.给多个变量赋同⼀个值 变量名1 = 变量名2 = 变量名3 = 值

例：a = b = c = 10

3.给多个变量赋不同的值 变量名1, 变量名2 = 值1, 值2

例：m, n = 100, 101

数据类型
整型

整数类型int，这⼀类数据都是整数

对象：1、2、3、100、20000

浮点型

浮点类型float，就是⼩数。之所以称为浮点，是因为按照科学记数法表示时，⼀个浮点数的⼩数点位置可变

对象：1.2、3.56

布尔类型

布尔类型bool，这个类型只有两个值True和False，⽤于描述某种状态是否成⽴

字符串类型
字符串类型str，字符串是以单引号或双引号括起来的⽂本

例：'hello',"bye"

当字符串⻓度为⼀时，称为字符

例：'?'

字符串是⼀个序列，容器型数据，把多个字符拼在⼀起

如何获取数据类型

type(变量或数据)

Caution

变量不具有类型，数据才有类型

x = 10
#获取变量对应数据的类型
cls = type(x)
print(cls)
#output:int

pi = 3.14
#获取变量对应数据的类型并且打印
print(type(pi))
#output:float

数据类型转换

转成整数 int(数据)

场景：1.对浮点数取整

2.字符串转成整数（数据必须满⾜整数格式要求）默认转换成⼗进制数据，若要转换其他进制的
字符串数据需要准许对应的进制

print(int('100'))
#output:100

print(int(0b1011))
#output:11，⼆进制转成⼗进制整型

print(int('0b1011'))
#output:Error，字符b不满⾜整型

print(int('0b1011', base=2))
#output:11，准许⼆进制

print(int('0x11', base=16))
#output:17，准许⼗六进制
 转成浮点数 float(数据)

场景：把字符串中的数据转成浮点数（数据必须满⾜整数格式要求）

print(float('100'))
#output:100.0

print(flaot('3.145'))
#output:3.145

转成字符串 str(数据)

这种转换是在数据外层添加了引号

nums = [12, 34, 56, 78]

print(str(nums))
#output:'[12, 34, 56, 78]'

指定序列的数据转成列表类型 list(容器型数据)

列表是序列型的数据，容器型的。只能转换容器型数据

操作：新建⼀个列表，元素来源于被转化的容器型数据

name1 = '王浩'
name2 = '少宁'
name3 = '王鑫'
print(name1)
print(name2)
print(name3)

names = ['王浩', '少宁', '王鑫']

print(names)

print(list('hello'))
#output:['h', 'e', 'l', 'l', 'o']

校验输⼊的数据是不是偶数

value = input('请输⼊⼀个整数:')
print('数据原类型:', type(value))
#进⾏转换
num = int(value)
checkout = num % 2 == 0
print(checkout)

运算符
算数运算符

+加法

数值中的加法

布尔类型bool数据和数值类型进⾏算数运算时，True = 1，False = 0

在字符串中'+'表示字符串的拼接，把多个字符串的内容拼接在⼀起形成⼀个新的字符串、

print(10 + True)
#output:11

new_s = 'hello' + ' ' + 'world'

print(new_s)
#output:hello world

-减法
数值中的减法

*乘法

数值中的乘法

在字符串中使⽤，只能乘正整数n，把字符串中字符重复n次

new_s = 'hello' * 3
#output:hellohellohello

/除法

数值中的除法，求商

print(10 / 3)
#output:3.33333333333

print(-10 / 3)
#output:-3.33333333333

//向下整除

结果是⼀个整数，⽐商⼩且最接近的整数

print(10 // 3)
#output:3

print(-10 // 3)
#output:-4

**求幂
 求指定数的指定次⽅

print(2 ** 3)
#output:8

%余数

除之后的余数

print(10 % 3)
#output:1

赋值运算符

1.简单赋值运算符 =

2.复合赋值运算符 +=、-=、*=、/=、//=、**=、%=

对指定的变量进⾏对应算数运算之后，再把结果赋值给变量

Caution

赋值运算符的优先级别最低，先运算等号右边的表达式，最后将结果赋值给左边的变量

x = 10
x += 15
#x = x + 15
print(x)
#output = 25

x = 3
x **= 3
print(x)
#output:27

⽐较运算符

<、>、<=、>=、==、!=

⽐较运算符的结果时布尔类型的bool

算数运算符的有优先级 > ⽐较运算符

x = 11
y = 12
#先执⾏加法，再进⾏⽐较，结果为布尔类型
print(x + 1 >= y)
#output:True

print(y - 2 >= x - 1)
 #output:True

print(y * 3 <= x * 3)
#output:False

print(x != y)
#output:True

字符串类型的数据也可以进⾏⽐较

相同位置的字符，⼀⼀进⾏⽐较，知道⽐较出来结果就结束⽐较

字符之间的⽐较是通过对应编码规则的⼗进制数据进⾏⽐较的

x = 'abc'
y = 'ab'
x > y
#前两个位置⼀样，第三个位置x有c
#output:True

#Ascii中a=97,b=98
print('a' > 'b')
#output:True
print('A' > 'a')
#output:False

Note

获取字符对应的⼗进制数据的⽅法

ord(变量或字符)

print(ord('a'))
#output:97

print(ord('你'))
#output:20320

逻辑运算符

⽐较运算符优先级 > 逻辑运算符

逻辑运算符优先级：not > and > or

逻辑与 and

并且的关系，双⽅成⽴，结果为真

Note

短路原则：如果左边的表达式确定为假，右边的表达式不参与运算，如果后边有or连接的逻辑运算会执⾏or表达式
 运算流程：左边不成⽴，结果取左边结果；左边成⽴，结果取右边结果

数据转化为布尔类型bool的柜⼦

数值类型：⾮0即为True

字符串：⾮空容器即为True

x = 10
y = 11
res = x + 1 > y and x < y
print(res)
#output = False

res = 10 and x < y#⾮布尔类型bool的数据参与逻辑运算时会把数据隐式转换成布尔类型

print(res)
#output:True

res = 10 and 5#运算会隐式转换，取值与原值

print(res)
#output:5

res = 0 and 17
print(res)
#output:0

逻辑或 or

或者的关系，双⽅有⼀⽅成⽴，结果为真

Note

短路原则：如果左边的表达式确定为真，右边的表达式不参与运算

运算流程：左边成⽴，结果取左边结果；左边不成⽴，结果取右边结果

res 0 or 1
print(res)
#output:1

Note

and和or可以组成三元运算符
 num1 = 17
num2 = 19
res = num1 > num2 and num1 or num2#先执⾏and然后or
print(res)
#output:19

num1 = 21
num2 = 19
res = num1 > num2 and num1 or num2#先执⾏and然后or
print(res)
#output:21

逻辑⾮ not

真变假，假变真

not True = False

not False = True

成员运算符

针对于容器型数据

in 判断某个元素是否在容器中

not in 判断某个元素是否不在容器中

s = 'nice to meet you'

print('to' in s)
#output:True

print('ot' in s)
#output:False

print('meet' not in s)
#output:False

身份运算符

针对数据的地址的

is 判断两个数据地址是否是⼀致的

is not 判断两个数据地址是否是不⼀致的

id(数据) -- 获取数据的地址
a = 10
b = 20
print(a is b)
#output:Fasle

a = 10
c = 10
print(c is a)
#output:True

Note

数值在内存中有缓存区，保存-5到256的数据

超过这个范围的数据，会在内存新开辟⼀块区域存放

但是Pycharm中有优化，⼀样的数据就在⼀样的地址（⾯试）

x = 300
y = 300
print(id(x) == id(y))
#output:False

位运算符

Note

⼆进制形态：原码、反码、补码

在运算时是按照补码运算的

假设8位存储7 - 6 = 1

7 --- 0b0000 0111

-6 --- 0b1000 0110

——————————

0b1000 1101 --- -13（按照原码是错的）

7 --- 0b0000 0111

-6 --- 0b1111 1001

——————————

0b0000 0000 --- 0（按照反码时错的，1溢出就没有了）

7 --- 0b0000 0111

-6 --- 0b1111 1010

——————————
 0b0000 0001 --- 1（按照原码是正确的）

假设8位存储7 - 8 = -1

7 --- 0b0000 0111

-8 --- 0b1111 1000

——————————

0b1111 1111 --- 1000 0001 = -1（是补码格式的负数，故转换成原码）

正数：原码、反码、补码相同

负数原码：正数⼆进制数的最⾼位置1（开辟的字节的最⾼位，计算机最少开辟1个字节8位）

负数的反码：除了符号位，其他按位取反

负数的补码：反码+1

Caution

位运算符计算时，符号位都参与运算，按照补码运算

按位与&

相同位进⾏与

print（7 & 6）
#0000 0111 & 0000 0110按位与
#output:6

print（7 & -6）

#0000 0111 & 1111 1010按位与
#output:2

按位或|
相同位进⾏或

print（7 | -6）
#0000 0111 & 1111 1010按位或
#output:-1

按位异或^

相同位上的数据如果相同，则位0；不同，则为1
 print(7 ^ -6)
#0000 0111 & 1111 1010按位异或
#output:-3

print(-3 ^ -6)
#output:7

⼀个数与相同的书异或两次，得到本身

Note

交换两个变量值的⽅式有三种（⾯试）

⽅式1：借助第三⽅变量

a = 10
b = 20
c = a
a = b
b = c
print(a,b)
#output:20,10

⽅式2：不借助第三⽅变量，异或和通过距离

a = 10
b = 20
a = a ^ b
b = a ^ b#b = 10
a = a ^ b#a = 10
print(a,b)
#output:20,10

a = a + b
b = a - b
a = a - b
print(a,b)
#output:20,10

⽅式3：Python独有（可以按照原值直接交换不需要第三⽅变量）

a = 10
b = 20
a,b = b,a

按位取反~

对应位0变1，1变0。取反之后如果是补码，⼀定要转换为原码
按位左移<<

将⼆进制数据向左移动指定的位数，空出位补0

print(1 << 3)
#0000 0001----000 0000 1000
#output:8

按位右移>>

将⼆进制数向右移动指定位数，左边根据符号位来补

Caution

对于左右移操作，如果是正数直接移，如果是负数，⼀定记住是对补码操作，最后结果要转换成原码

输⼊输出
print输出功能

把程序中的数据输出到控制台，呈现给⽤户

语法：print(*values, sep=' ', end='\n', file)

*values：输出可以输出多个数据，字符串之间使⽤逗号隔开也可以连接数据，中间没有分割，使⽤+

sep：分隔符，在输出的⽬的地呈现数据时，每个数据之间的分隔符，默认是空格

end：输出数据的结尾符，\是转义符，默认是换⾏

'\n'：换⾏

'\t'：制表符tab

'\r'：回⻋

'\f'：换⻚

'\v'：纵向制表符

file：输出⽬的地，默认是控制台

Note

转义符转两次可以输出原字符

print('\table')
#output: able
print('\\table')
#output:table

input输⼊功能
跟⽤户进⾏交互，由⽤户在控制台中录⼊数据

input('提示语')

在控制台输⼊数据，回⻋结束输⼊，会返回输⼊的值。⽆论输⼊什么格式，返回的都是字符串

value = input('请输⼊：')
print('录⼊的数据是：'，value)

字符串的格式化

根据⼀定格式的⽂本来呈现数据

例：我叫XX，今年XX岁

'我叫%s，今年%d岁' %（姓名, 年龄）

%在字符串中的应⽤

固定⽂本内容中如果存在未知项，需要使⽤占位符标记，然后通过%分割对占位符进⾏赋值，有⼏个值，⼏个占位
符，且⼀⼀对应

占位符：

%s任意类型数据

%d整型数据

%0nd n就是按照⼏位数格式化，不⾜n位前边补0

%f浮点型数据

%.nf n就是保留⼏位⼩数四舍五⼊

name = input('请输⼊姓名：')
age = int(input('请输⼊年龄：'))
info = '我叫%s，今年%02d岁' % (name, age)
print(info)
#output:我叫XXX，今年XX岁

f标记字符串进⾏格式化

3.6之后才出现

f'我叫{数据}，今年{数据}'

保留⼏位⼩数{数据:.nf}

按照⼏位格式化{数据:0nd}
 name = input('请输⼊姓名：')
age = int(input('请输⼊年龄：'))
score = int(input('请输⼊成绩：'))
info = f'我叫{name}，今年{age:02d}岁，成绩是{score:.2f}'
print(info)
#output:我叫XXX，今年XX岁，成绩是XX.XX

数据结构
列表List

列表：由⼀系列按照特定顺序排列的元素组成，可以是不同类型

格式：[ ]

bicycles = ['trek', 'cannoondale', 'specialied']

print(bicycles)
#output:['trek', 'cannoondale', 'specialized']

访问列表元素

索引从0开始,-1是倒数第⼀个，-2是倒数第⼆个以此类推

print(bicycles[0])#只返回该元素，不包括⽅括号和引号
#output:trek
print(bicycles[-1])#访问最后⼀个元素
#output:specialized

Caution

如果访问的索引超出列表，会引发错误，最好使⽤-1来访问最后的元素，如果列表为空，怎么访问都会出现错误

在列表中添加元素

1.在列表末尾添加元素append(内容)

bicycles = ['trek', 'cannoondale', 'specialied']

bicycles.append('light')
print(bicycles)
#output:['trek', 'cannoondale', 'specialied', 'light']
#可以先创建⼀个空列表，利⽤append()动态创建列表元素
empty = []
empty.append(1)
empty.append('er')
empty.append('我是谁')
print(empty)
2.在列表中插⼊元素insert(索引，内容)

bicycles = ['trek', 'cannoondale', 'specialied']

bicycles.insert(2, 'light')
print(bicycles)

在列表中删除元素

1.已知元素索引，可以使⽤del

bicycles = ['trek', 'cannoondale', 'specialied']

del bicycles[1]#删除第⼆个元素
print(bicycles)

2.删除列表元素，并可继续使⽤pop(索引)

bicycles = ['trek', 'cannoondale', 'specialied']

popped_bicycles = bicycles.pop()#弹出最后⼀个元素，并赋值给变量
print(bicycles)
print(popped_bicycles)
#output:['trek', 'cannoondale']
#specialied

popped_bicycles = bicycles.pop(1)#弹出第⼆个元素，并赋值给变量

3.根据值删除元素，适⽤于不知道位置但是直到想删除的元素内容remove(),也可以

bicycles = ['trek', 'cannoondale', 'specialied']

bicycles.remove('trek')
print(bicycles)

remove()删的元素也可以继续使⽤

bicycles = ['trek', 'cannoondale', 'specialied']

deleted = 'trek'
bicycles.remove(deleted)
print(bicycles)
print(deleted)#被删除的元素，任存在变量中
#output:['cannoondale', 'specialied']
#trek

组织列表

1.sort()⽅法对列表进⾏永久性排序，按照字⺟顺序
 cars = ['bmw', 'audi', 'toyota', 'subaru']
cars.sort()#按照字⺟表顺序
print(cars)
#output:['audi', 'bmw', 'subaru', 'toyota']

cars.sort(reverse = True)#按照字⺟表反顺序
print(cars)
#output:['toyota', 'subaru', 'bmw', 'audi']

2.sorted()进⾏临时排序

保留原来的顺序，并以新的顺序显示

cars = ['bmw', 'audi', 'toyota', 'subaru']

print('原顺序', cars)
print('临时顺序', sorted(cars))#临时排序
#output:原顺序 ['bmw', 'audi', 'toyota', 'subaru']
#临时顺序 ['audi', 'bmw', 'subaru', 'toyota']

3.反转打印列表reverse()，也是永久改变

cars = ['bmw', 'audi', 'toyota', 'subaru']

cars.reverse()
print(cars)

4.确定列表⻓度len()

cars = ['bmw', 'audi', 'toyota', 'subaru']

print(len(cars))

遍历列表

通过for，依次遍历

cars = ['bmw', 'audi', 'toyota', 'subaru']

for car in cars:
print(car)

可以添加其他操作

cars = ['bmw', 'audi', 'toyota', 'subaru']

for car in cars:
print(car+',very good！')
print('Everyone is good')#for循环外，只执⾏⼀次

range功能⽣成数值列表
⽤于⽣成等差的整数序列

1.range(stop)在[0，stop-1]的区间中按照步⻓为1⽣成等差序列

a = range(10)
print(a)
#output = 0 1 2 3 4 5 6 7 8 9

2.range(start, stop)在[start，stop-1]的区间中按照步⻓为1⽣成等差序列

a = range(1, 10)
print(a)
#output = 1 2 3 4 5 6 7 8 9

3.range(start, stop, step)从start开始，按照步⻓为step成等差序列，到stop但是不包含stop

a = range(1, 10, 3)
print(a)
#output = 1 4 7

a = range(1, 10, -1)

print(a)
#output:null

a = range(10, 0, -1)
print(a)
#output = 10 9 8 7 6 5 4 3 2 1

例：1-100⽣成个位数为3的数据

data = list(range(3, 100, 10))

print(data)

例：-1到-10的序列

data = list(range(-1, -11, -1))

print(data)

例：⽣成⼀个序列从-10到+10

data = list(range(-10, 11))

print(data)

列表切⽚

通过指定起始元素索引和最后⼀个元素的写⼀个索引，索引从0开始
 Note

和range()类似，范围不包含最后⼀个索引

cars = ['bmw', 'audi', 'toyota', 'subaru']

print(cars[0:2])
print(cars[1:4])

#不指定第⼀个⼦集，⾃动从第⼀个开始
print(cars[:2])
#不指定最后⼀个，⾃动到最后⼀个
print(cars[1:])
#开头结尾都不写，可以简单地遍历全部
print(cars[:])
#也可以使⽤负数索引
print(cars[-1:])

#遍历切⽚也可以⽤for
for car in cars[:2]:
print(car)

复制列表

通过创建⼀个包含整个列表的切⽚

cars = ['bmw', 'audi', 'toyota', 'subaru']

copy = cars[:]
print(cars)
print(copy)

元组Tuple

元组：不可以修改的列表就是元组

定义元组使⽤()，也可以通过索引来访问元组，类似于列表

dimensions = (200, 50)

print(dimensions[0])

遍历元组

和列表相同使⽤for

dimensions = (200, 50)

for dimension in dimensions:
print(dimension)

修改元组变量
虽然不能修改元组的元素，但是可以给储存元组的变量赋值，可以重新定义整个元组(列表也可以)

dimensions = (200, 50)

for dimension in dimensions:
print(dimension)
dimensions = (100, 90)
for dimension in dimensions:
print(dimension)

字典Dictionary

字典：⼀系列的键—值对，每个键对应⼀个值，可以通过键来访问与之关联的值（关联的值可以是任何对象）

字典格式：字典名 = {'键1' = 值1，.......}

访问字典中的值

alien_0 = {'color': 'green', 'points': '5'}

print(alien_0['color'])
print(alien_0['points'])

添加键—值对

字典是动态结构，可以随时修改。要添加可以：字典名['键'] = 值

alien_0 = {'color': 'green', 'points': '5'}

alien_0['x_position'] = 0
alien_0['y_position'] = 25
print(alien_0['x_position'])
print(alien_0['y_position'])
print(alien_0)

创建空字典

通常在使⽤字典存储数据，或者编写能⾃动⽣成⼤量键—值对的代码时，通常先创建空字典

alien_0 = {}
alien_0['x_position'] = 0
alien_0['y_position'] = 25

修改字典中的值

只需要重新给键赋值

alien_0 = {'color': 'green', 'points': '5'}

alien_0['color'] = 'yellow'
print(alien_0['color'])
 alien_0 = {'x_position': 0, 'y_position': 25, 'speed': 'medium'}
x_increment = 0
print('original x_position'+str(alien_0['x_position']))
#向右移动外星⼈，外星⼈当前速度决定其移动多远
if alien_0['speed'] == 'slow':
x_increment = 1
elif alien_0['speed'] == 'medium':
x_increment = 2
elif alien_0['speed'] == 'high':
x_increment = 3
alien_0['x_position'] += x_increment
print(('new x_position'+str(alien_0['x_position'])))

删除键—值对

del语句,永久删除

alien_0 = {'x_position': 0, 'y_position': 25, 'speed': 'medium'}

del alien_0['y_position']
print(alien_0)

整理字典格式

将较⻓的字典规整的显示，每⼀⾏⼀个键值对，以逗号和tab结尾，最好在最后⼀个键值对之后也加上⼀个逗号，⽅便之后
修改

favorite_language = {
'jen': 'python',
'sarah': 'C',
'edward': 'ruby',
'phil': 'C++',
}
print(favorite_language)

遍历字典

多种⽅式：键值对，键，值

1.遍历键值对，可以使⽤for和items()⽅法

items()会返回⼀个键值对列表，for循环依次将键和值存储到变量中

Note

不关⼼键值对的顺序，只关⼼对应关系

#存储⽤户的⽤户名、名和性
user_0 = {
'username': 'efermi',
'first': 'enrico',
 'last': 'fermi',
}
for key, value in user_0.items():
print('\nKey: '+key)#确保每⼀个键值对之前都有空⾏
print('Value：'+value)

favorite_language = {
'jen': 'python',
'sarah': 'C',
'edward': 'ruby',
'phil': 'C++',
}
for k, v in favorite_language.items():
print(f"{k}'s favorite language is {v}")

2.遍历所有键

可以使⽤key()⽅法,或者直接遍历（遍历字典默认遍历所有键）

也可以按照特定的顺序，⽅法是在for中使⽤组织列表的⽅法（sorted等）

favorite_language = {
'jen': 'python',
'sarah': 'C',
'edward': 'ruby',
'phil': 'C++',
}
#直接遍历for name in favorite_language
for name in favorite_language.keys():
print(name)

for name in sorted(favorite_language.keys()):#按照字⺟顺序排序

print(name)

例：

favorite_language = {
'jen': 'python',
'sarah': 'C',
'edward': 'ruby',
'phil': 'C++',
}
friends = ['jen', 'phil']
for name in favorite_language.keys():
if name in friends:
print(f"\n{name}'s favorite language is", favorite_language[name])

例：key()并⾮只能⽤来遍历，它会返回⼀个列表
 favorite_language = {
'jen': 'python',
'sarah': 'C',
'edward': 'ruby',
'phil': 'C++',
}
if 'peter' not in favorite_language.keys():#判断peter是否在key()返回的列表中
print('no peter')

3.遍历所有的值

使⽤values⽅法

favorite_language = {
'jen': 'python',
'sarah': 'C',
'edward': 'ruby',
'phil': 'C++',
}
for language in favorite_language.values():
print(language)

这⾥只遍历了所有的值，没有考虑吧是否有重复如果要考虑重复问题，可以使⽤集合set()

favorite_language = {
'jen': 'python',
'sarah': 'C',
'edward': 'ruby',
'phil': 'C++',
}
for language in set(favorite_language.values()):
print(language)

嵌套

有时需要将⼀系列字典存储在列表中，或者将列表作为值存储在字典中，这称为嵌套

1.在列表中存字典

⽐要存储多个外星⼈的信息

alien_0 = {'color': 'green', 'points': 5}

alien_1 = {'color': 'yellow', 'points': 10}
alien_2 = {'color': 'red', 'points': 15}
#多个字典存储在列表
aliens = [alien_0, alien_1, alien_2]
#遍历
for alien in aliens:
print(alien)
2.在字典中存列表

pizza = {
'crust': 'thick',
'toppings': ['mushrooms', 'extra cheese']
}
print(pizza['crust'])
for topping in pizza['toppings']:
print(topping)

3.在字典中存字典

users = {
'jason': {
'first': 'albert',
'last': 'einstein',
'location': 'princeton',
},
'lily': {
'first': 'peter',
'last': 'paker',
'location': 'queens',
}
}
for user, info in users.items():
print('\nUsername: '+user)
print('Full name: '+info['first'], info['last'])
print('Location: '+info['location'])

集合Set

类似列表，但是每个元素必须独⼀⽆⼆

随机模块random
⽣成随机数

import random#需要导⼊包

1.在指定序列中获取⼀个随机数

random.choice(序列)

seq = 'qwertyuiopasdfghjklzxcvbnm'
rst = random.choice(seq)
print(rst)
 2.在指定的整数区间范围内，随机选择⼀个整数

random.randint(start, stop) 在[start, stop]中随机选择⼀个整数（和range区别是包含stop）

rst = random.randint(10, 100)

print()rst

3.在指定的整数区间范围内，随机选择⼀个整数，但是不包含结束值

random.randrange() === > random.choice(range())

4.在[0，1)之间随机⽣成⼀个数

random.random()

5.在指定序列中根据指定个数n，随机产⽣多个互不重复的元素

random.sample(序列，个数)

seq = 'qwertyuiopasdfghjklzxcvbnm'
rst = random.sample(seq, 5)
print(list(rst))

6.在指定序列中根据指定个数n，随机产⽣多个可能重复的元素

random.choices(序列，k=个数)

seq = 'qwertyuiopasdfghjklzxcvbnm'
rst = random.choices(seq, k=6)
print(list(rst))

7.随机打乱序列中的元素顺序

random.shuffle(序列)必须是可变序列,⽆返回值，直接影响序列本身

seq = list('123456789')
random.shuffle(seq)
print(seq)

例：1-50中随机选择⼀个整数赋值给x，在30-60随机选择⼀个整数赋值给y，获取x,y中的最⼤值

x = random.randint(1, 50)
y = random.randint(30, 60)
max = x > y and x or y
print(max)

流程控制语句
顺序语句

代码的执⾏顺序：从上向下执⾏

语句：语句结束的标记是分号，python不需要；但是如果⼀⾏包括多条，必须⽤分号

分⽀语句

1.如果满⾜条件，就做某件事

if 条件：

事情

2.如果满⾜条件，就做某件事；否则，就做另⼀件事

if 条件：

事情1

else：

事情2

3.如果满⾜条件1，就做事情1；否则，满⾜条件2，做事情2；否则3.......否则都不满⾜，做某件事

if 条件1：

事情1

elif 条件2：

事情2

elif 条件3：

事情3

.........

elif 条件n：

事情n

else：

事情n+1

例：键盘录⼊⼀个数，判断能不能被3整除或能不能被5整除

inp = int(input('请输⼊⼀个整数'))
if inp % 3 == 0 or inp % 5 ==0:
print('可以被3或者5整除')
else:
print('不是可以被3或者5整除的数')
print('运算完成')
例：键盘录⼊⼀个季节

如果是春，输出春意盎然

如果是夏，输出烈⽇炎炎

如果是秋，输出硕果累累

如果是东，输出⽩雪皑皑

inp = input('请输⼊⼀个季节')
if inp == '春':
print('春意盎然')
elif inp == '夏':
print('烈⽇炎炎')
elif inp == '秋':
print('硕果累累')
elif inp == '冬':
print('⽩雪皑皑')
else:
print('输⼊的不是季节')

例：随机⽣成⼀个100-300范围内的整数，赋值给sys_num

⽤户录⼊⼀个100-300的整数赋值给user_num

如果⽤户录⼊的⽐随机⽣成的⼤，提示打了

如果⽤户录⼊的⽐随机⽣成的⼩，提示⼩了

如果⽤户录⼊的与随机⽣成的相等，提示恭喜你运⽓不错

import random
sys_num = random.randint(100,300)
user_num = int(input('请输⼊⼀个100-300的整数:'))
if user_num > sys_num:
print('⼤了')
elif user_num < sys_num:
print('⼩了')
else:
print('恭喜你运⽓不错')

循环语句

循环：周⽽复始重复做某⼀件事

循环分为两种：

1.达到⽬的就结束

2.没有结束的⼀直做下去—死循环

Python中提供的循环机制，两种：while，for
 1.while主要针对于明确的循环条件

2.for主要针对于序列元素的遍历，或者针对明确次数的循环

Note

新的三元运算符

格式：表达式1 if 条件表达式 else 表达式2

先判断条件表达式是个否成⽴，成⽴执⾏表达式1，不成⽴执⾏表达式2

return a if a > b else b

while循环

语法格式：

while 条件:

重复的操作

解读：当循环条件成⽴时，执⾏重复操作，执⾏完⼀次会判断条件是否成⽴，成⽴则继续循环，否则停⽌

例：罚跑⼗圈，需要⼀个计数器，没有到10继续跑下去

count = 0
while count < 10:
print(f'running lap{count + 1}')
print(f'finished{count}lap')
print('------------')
count +=1
print("it's all done")

例：猜数游戏

随机在100-150⽣成⼀个整数，判断⽤户录⼊的和随机⽣成的⼤⼩

import random
sys_num = random.randint(100, 150)
user_num = int(input('please enter a number between 100 and 150:'))
while user_num != sys_num:
if user_num > sys_num:
print('smaller')
elif user_num < sys_num:
print('larger')
user_num = int(input('please enter another number between 100 and 150:'))
print('you have found the right number')

例：打印1-10中的每⼀个数
 num = 1
while num <= 10:
print(num)
num += 1

例：求1+2+...+10

num = 1
total = 0
while num <= 10:
total += num
num += 1
print(f'sum is {total}')

死循环

例：⼀段绳⼦300m，每天减少⼀半，问多少天后可以⼩于3m

length = 300
count = 0
while 1:
length /= 2
count += 1
print(count)
if length < 3:
break

while-else格式

Caution

如果循环是被break结束的，else不执⾏

while 条件：

操作

else：

当且仅当循环条件不成⽴时执⾏else

i = 1
while i <= 10:
print(i)
if i == 5:
break
i += 1
else:
print('all done')
while循环中的关键字break和continue

break：强制结束循环

例：打印1-100中的数据，遇到个位数时5同时能被9整除时，结束循环

num = 1
while num <= 100:
print(num)
if num % 10 == 5 and num % 9 == 0:
break
num += 1

continue：结束当前次，继续判断条件，成⽴进⾏下⼀次循环，否则终⽌

例：输⼊1-10中的偶数

num = 1
while num <= 10:
if num % 2 != 0:
num += 1
continue
print(num)
num += 1

Note

break和continue之后不能跟平级代码，因为永远不运⾏

for循环

遍历序列中的每⼀个元素或者明确循环次数

语法结构：

for 变量 in 序列：

操作

for 变量in序列：

操作

else：

当且仅当，for循环序列元素全部遍历完成，并且不是被break结束

依次获取序列中的元素，将元素值赋值给变量，通过变量进⾏相应操作
 s = 'hello'
for ch in s:
print(ch)

例：使⽤for输出1-10的数据

for ch in range(1,11):
print(ch)

例：猜数游戏，最多猜五次

import random
sys_num = random.randint(100, 150)
for ch in range (1, 6):
print(f'第{ch}次')
user_num = int(input('请输⼊100-150：'))
if user_num > sys_num:
print('smaller')
elif user_num < sys_num:
print('larger')
else:
print('you have found the right number')
break
else:
print('次数⽤完')

例：打印‘AbcDeFGhijk’⾥边的⼤写字⺟

字符串⽐较⼤⼩本质⽐较的每⼀位的Ascii码

s = 'AbcDeFGhijk'
for ch in s:
if 'A' <= ch <= 'Z':
print(ch)

例：获取所有⽔仙花数

for num in range(100,1000):

hundreds = num // 100
decade = num % 100 // 10
unit = num % 10
if hundreds ** 3 + decade ** 3 + unit ** 3 == num:
print(num)

循环嵌套

循环中带循环
使⽤循环嵌套的情况，有⾏有列，外层控制⾏，内层控制列

例：三⾏六列*

for m in range(3):
for i in range(1, 7):
print('*', end='')
print()

例：第⼀⾏第⼆⾏***依次递减

for m in range(1, 5):

for i in range(5 - m):
print('*', end='')
print()

例：第⼀⾏*第⼆⾏**依次五⾏

for m in range(1, 6):

for i in range(m):
print('*', end='')
print()

例：乘法⼝诀表

for r in range(1, 10):

for c in range(1, r+1):
print(f'{c}*{r}=',r*c , end='\t')
print()

pip指令
安装第三⽅包使⽤pip

常⽤指令

pip install 包名：安装

pip uninstall 包名：卸载

pip list：显示已经安装的包

pillow图像处理
PIL：Python Imaging Library在python2中处理图像的包
pillow是PIL的分⽀，⽀持python3。安装是叫pillow，使⽤时还是PIL

1.加载图⽚，显示图⽚信息等

from PIL import Image#从PIL库中导⼊Image模块

#加载图⽚
image = Image.open(路径)#默认只读，路径必须存在
print(image)
#output:图⽚的基本信息

#显示图⽚
image.show()
#获取尺⼨
print(image.size)
#获取模式
print(image.mode)
#以格式化的形式，显示图⽚格式
print(image.format)
#图⽚详细信息
print(image.info)\
#保存图⽚
image.save(路径)

2.修改图⽚

from PIL import Image#从PIL库中导⼊Image模块

image = Image.open(路径)#默认只读，路径必须存在
#设置图⽚尺⼨,变形不是裁剪
image.resize(width, height)
#等⽐例缩放
image.resize(image.size[0]/3, image.size[1]/3)#必须是整数
#修改图⽚⾊系,彩⾊转灰⾊
image.convert(mode)#mode是L是灰⾊，RGB彩⾊
#进⾏过滤
from PIL import ImageFilter
image.filter(模式)#例image.filter(ImageFilter.EMBOSS)
#裁剪图⽚
image.crop(box=(left, upper, right, lower))#填⼊边界坐标，原点是左上⻆，x向右y向下，前两个是起始点xy，后两
个是终点xy
#图⽚旋转
image.rotate(angel，center=(旋转点坐标))#旋转点默认为中间
#图⽚翻转
image.transpose(method)#method是以哪⼀边旋转
#粘贴⽔印
image.paste(粘贴的图⽚，box=(坐标位置))#直接粘贴原图，显示的时候显示原图
#打⽂字⽔印
from PIL import ImageDraw
draw = ImageDraw.Draw(图⽚)#要进⾏绘制的图⽚,通过draw对象进⾏绘制
draw.text(坐标，内容，fill=颜⾊，font=字体)
函数
⾃定义函数

函数：具有独⽴功能的代码进⾏封装，便于使⽤这个功能时直接调⽤

函数分为两种：

系统函数

⾃定义函数

格式：

def 函数名（形式参数1，形式参数2，.....）

功能体

return 功能的运算结果

解读：

def：python关键字，⽤于定义函数

函数名：⾃定义的名字，必须遵守规范

()：必须有的

形式参数：形参，⼀个变量，功能中未知项的个数决定形参个数

实际参数：实参，调⽤函数时，⽤于给形参赋值

return：结束函数，并且把结果返回到调⽤位置，如果不需要可以不写，或者return none

例：圆的⾯积

#定义
def get_area(r):
area = 3.14 * r ** 2
return area
#调⽤
print(get_area(5))

例：获取两个数的最⼤值

#定义
def get_max(a, b)
return a if a > b else return b

例：封装⼀个函数⽐较两个数的⼤⼩，前者⼤于后者返回1，前者⼩于后者返回-1，两者相等返回0
 def compare(a, b):
if a == b:
return 0
return 1 if a > b else -1

例：封装⼀个函数判断两数是否相等

def judge_equal(a, b):

return a == b

函数也是⼀种类型的数据：function

函数名表示函数本身，函数名（）表示要调⽤函数，获得return的结果

如果直接 变量=函数名：把函数地址赋值给变量，变量和函数有同⼀功能

关键字实参

传参时指定形参名，适合有很多形参时使⽤，⽆需考虑形参顺序

def describe_pet(animal_type, pet_name):

print('\nI have a ' + animal_type)
print('My ' + animal_type + ' name is ' + pet_name)
describe_pet(animal_type='hamster', pet_name='harry')#关键字实参
describe_pet('hamster', 'harry')#按照形参顺序直接传参

默认值

给形参设置默认值，传参时可以不传

Note

在使⽤默认值时，把没有默认值的形参放在前边，有默认值的放在后边

def describe_pet(animal_type, pet_name='harry'):

print('\nI have a ' + animal_type)
print('My ' + animal_type + ' name is ' + pet_name)
describe_pet(animal_type='hamster')

可以使⽤默认值的⽅法，让形参变得可选

给可选形参默认值为空字符串
def get_name(first, last, middle=''):
if middle:
full = first + ' ' + middle + ' ' + last
else:
full = first + ' ' + last
return full
people1 = get_name('A', 'B', 'C')
print(people1)
people2 = get_name('A', 'B')
print(people2)

传递列表

def greet_users(names):
#向列表中每⼀个⼈问候
for name in names:
msg = 'hello ' + name + '!'
print(msg)
usernames =['peter', 'lily', 'jason']
greet_users(usernames)

在函数中修改列表

def print_models(unprinted_models, completed_models):

while unprinted_models:
current_model = unprinted_models.pop()
print(f'Printing model: {current_model}')
completed_models.append(current_model)

def show_completed_models(completed_models):
print('all done')
for model in completed_models:
print(model)

unprinted_models = ['A', 'B', 'C']

completed_models = []
print_models(unprinted_models, completed_models)
show_completed_models(completed_models)

如果想要保留原件，那么传⼊的时候传⼊附件即可

unprinted_models = ['A', 'B', 'C']

completed_models = []
print_models(unprinted_models[:], completed_models)
#unprinted_models不会被修改，因为传⼊的时附件unprinted_models[:]
#completed_models可以修改
传递任意数量的实参

1.在不知道函数需要接受多少个实参时，可以使⽤*

*形参名 会创建⼀个名为形参名的空元组，并封装接收到的数据（⽆论收到⼏个值，都会创建⼀个元组）

例：

def make_pizza(*toppings):
print(toppings)
for topping in toppings:
print('- ' + topping)
make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

Caution

任意形参在定义函数时必须放在最后

2.但是如果也不知道传⼊参数的类型，可以使⽤任意数量的关键字实参

**形参名，会创建⼀个以形参名为名的空字典，并肩收到的所有键值对都封装进去

def build_profile(first, last, **user_info):

profile = {}#创建空字典存放⽤户的⼀切
profile['first_name'] = first
profile['last_name'] = last
for key, value in user_info.items():#将user_info字典中的键值对，转移到profile中
profile[key] = value
return profile
user_profile = build_profile('albert', 'einstein', location='princeton', field= 'physics')
print(user_profile)

导⼊函数

import：导⼊整个模块

from 模块 import 函数名1，函数名2：导⼊模块中的⼀个或⼏个函数

from 模块 import 函数名1 as 函数别名：导⼊函数的同时，另外起⼀个别名

import 模块 as 模块别名：导⼊模块的同时，另外起⼀个别名

from 模块 import *：导⼊模块中的所有函数，使⽤时⽆需句点法表示，但是不建议使⽤

匿名函数lambda

匿名函数：简单格式的函数的简化

lambda 形参1，形参2，...：功能结果

例：封装⼀个函数判断两数是否相等
 lambda a, b : a == b
print((lambda a, b: a == b)(10, 20))#在函数后边(实参，实参....)进⾏调⽤

#等价于
def function(a, b):
return a == b

⾯向对象的编程
类和对象

类：具有相同特征的数据的⼀个抽象描述

对象：类中的具体存在的某个实体

⽣活中的例⼦：
⼈类---类型
特朗普---对象

电脑---类型
MacbookPro2020---对象

创建和使⽤类

创建Dog类：⼀般⾸字⺟⼤写，根据Dog类每个实例都将储存名字和年龄，赋予了⼩狗蹲下sit()打滚roll_over()的能⼒

类中的函数称为⽅法

构造函数__ init __() ⽅法，根据类创建实例时会⾃动运⾏

Note

必须有self形参，因为创建Dog实例时，将⾃动传⼊实参self。每个与类相关联的⽅法调⽤，都⾃动传递实参self，是
⼀个指向实⼒本身的引⽤，让实例能够访问类中的属性和⽅法

class Dog():#定义了⼀个名为Dog的类，定义的是空的
def __init__(self, name, age):#self必不可少，必须在⾸位
#初始化name和age
self.name = name#将实参传⼊self的属性中
self.age = age
def sit(self):
print('蹲下了')
def roll_over(self):
print('打滚了')

析构函数__ del __（）⽤于清理对象占⽤的资源

def __del__(self):
release_resource(self.resource)

根据类创建实例

实例⼀般⾸字⺟⼩写，便于区分实例和类

class Dog()
----snip----
my_dog = Dog('peter', 6)
print(my_dog.name)#访问属性
print(my_dog.age)
my_dog.sit()#创建之后可以使⽤类中的任何⽅法
my_dog.roll_over()

使⽤类和实例

class Car():
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
def get_descriptive_name(self):
long_name = str(self.year) + ' ' + self.make + ' ' + self.model
return long_name
my_car = Car('audi', 'a4', '2016')
print(my_car.get_descriptive_name())

可以给属性加默认值

增加⾥程表属性和读取功能

class Car():
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer_reading = 0#新增有默认值的⾥程表属性
def get_descriptive_name(self):
long_name = str(self.year) + ' ' + self.make + ' ' + self.model
return long_name
def read_odometer(self):
print('total: ', self.odometer_reading)
my_car = Car('audi', 'a4', '2016')
print(my_car.get_descriptive_name())
my_car.read_odometer()
修改属性的值

可以直接修改实例属性，也可以编写特殊的⽅法进⾏修改

1.直接修改属性的值

class Car():
----snip----
my_car = Car('audi', 'a4', '2016')
print(my_car.get_descriptive_name())
my_car.read_odometer()
my_car.odometer_reading = 25#直接修改属性值
my_car.read_odometer()

2.通过⽅法修改属性值

class Car():
----snip----
def update_odometer(self, mileage):
self.odometer_reading = mileage#此处只是简单的修改，可以继续扩展
my_car = Car('audi', 'a4', '2016')
print(my_car.get_descriptive_name())
my_car.read_odometer()
my_car.update_odometer(27)
my_car.read_odometer()

继承

编写类时，并⾮只能从空⽩开始，如果编写的类时另⼀个现成类的特殊版本，可使⽤继承。

原类称为⽗类，新类称为⼦类

继承时⼦类⾃动获得⽗类的所有属性和⽅法，同时还可以定义⾃⼰的属性和⽅法

⼦类的创建

class Car():
----snip----#创建⼦类时，⽗类必须包含在当前⽂件
class ElectricCar(Car):#创建⼦类必须传⼊⽗类
def __init__(self, make, model, year):#初始化⽗类属性，接受创建⽗类需要的信息
super().__init__(make, model, year)#特殊函数，关联⽗类⼦类，让⼦类实例包含⽗类所有属性
#⽗类也称为超类superclass
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())

给⼦类添加新的属性和⽅法
class Car():
----snip----
class ElectricCar(Car):
def __init__(self, make, model, year):#初始化⽗类属性
super().__init__(make, model, year)#关联
self.battery_size =70#添加新的属性
def describe_battery(self):
print('battery_life: ', str(self.battery_size))
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()

将实例⽤作属性

当不断给⼦类增加细节时，会有很多针对同⽅⾯事情的⽅法或者属性，此时可以提取出来放到⼀个新的类中，并将该类当
作⼦类的⼀个属性

class Car():
----snip----
class Battery():
def __init__(self, battery_size=70):
self.battery_size = battery_size
def describe_battery(self):
print('battery: ', self.battery_size)
class ElectricCar(Car):
def __init__(self, make, model, year):
super().__init__(make, model, year)
self.battery = Battery()#将实例⽤作属性
my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()#使⽤实例属性的⽅法时，句号法中间要有当作属性的实例

私有属性

1. 使⽤单下划线 _：表示⼀种“内部使⽤”属性，但并不是完全私有。约定上不建议在外部访问，但仍然可以访问。

2. 使⽤双下划线 __：表示“强制私有”属性，会触发名称改写机制，使得外部更难直接访问。只能通过内部⽅法修改

class Car():
----snip----
class Battery():
def __init__(self, battery_size=70):
self.__battery_size = battery_size#私有属性
def describe_battery(self):
print('battery: ', self._battery_size)
class ElectricCar(Car):
def __init__(self, make, model, year):
super().__init__(make, model, year)
self.battery = Battery()#将实例⽤作属性
 my_tesla = ElectricCar('tesla', 'model s', 2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()#使⽤实例属性的⽅法时，句号法中间要有当作属性的实

多态

多态性允许相同的接⼝或⽅法在不同类中的实现有所不同。即多个类可以定义同样的⽅法名称，但实现不同的功能，这样
在不改变代码的前提下，可以对不同对象进⾏操作。

class Animal:
def speak(self):
pass # 定义⼀个通⽤⽅法，具体实现由⼦类完成

class Dog(Animal):
def speak(self):
print("Woof")

class Cat(Animal):
def speak(self):
print("Meow")

# 调⽤ speak ⽅法，⽆论是 Dog 还是 Cat 都可以调⽤同名⽅法

for animal in (Dog(), Cat()):
animal.speak() # 输出：Woof, Meow

抽象

抽象是指将共同的特征提取出来，定义为⼀个抽象类，作为⼦类的模板。Python 提供 abc 模块（Abstract Base

Classes），可以使⽤ @abstractmethod 装饰器定义抽象⽅法，要求⼦类必须实现这些⽅法。

from abc import ABC, abstractmethod

class Animal(ABC):
@abstractmethod
def speak(self):
pass # 定义抽象⽅法，⼦类必须实现

class Dog(Animal):
def speak(self):
print("Woof")

# 不能直接实例化 Animal，因为它包含抽象⽅法
# animal = Animal() # 这会报错
my_dog = Dog()
my_dog.speak() # 输出：Woof

导⼊类
 from ⽂件名 import 类名
from ⽂件名 import 类名1，类名2...
import ⽂件名#导⼊整个模块
from ⽂件名 import*#导⼊模块中所有的类

⽂件处理
打开⽂件
open()函数

open(''⽂件的路径'，打开模式，⽂件编码⽅式)

⼏种模式

r：read只读，要求路径中的⽂件必须存在，默认只读

w：write只写，⽂件不存在会创建，存在的会清空

a：append只写，⽂件不存在会创建，存在不会清空

r+：读和写

with open('data.txt') as file_object:

contents = file_object.read()#读取全部内容，最后会有个空⾏
print(contents.rstrip())#.restrip⽤来删除最后的空⾏，可以不⽤.strip可以删除空格

with关键字：在不需要使⽤⽂件时，⾃动关闭，open（）返回的对象只在with代码块中可以⽤

逐⾏读取

使⽤for循环

with open('data.txt') as file_object:

for line in file_object:#默认逐⾏输出
print(line)

包含⽂件各⾏的列表

存在列表⾥，with代码块外也可以⽤

readlines()：读取⽂件中的每⼀⾏，并将其存⼊⼀个列表

file_name = 'data.txt'
with open(file_name) as file_object:
lines = file_object.readlines()
for line in lines:#默认逐⾏输出
print(line)

写⼊⽂件
.write()⽅法，只能写字符串

#使⽤print()
file_handle = open('data.txt', 'w', encoding='utf-8')#如果以附加模式r打开，则是添加内容
print('nice to meet you', file= file_handle)
#另⼀种
file_name = 'data.txt'
with open(file_name, 'w') as file_object:
file_object.write('I love programming\n')
file_object.write('hahah\n')#默认输⼊不换⾏，需要在每⾏后边加换⾏符