本篇根据老师画的重点基本上将期末考点都囊括了

如果发现有错误或遗漏欢迎各位在学习群里指正

可能看起来稍微有点多，但其实大部分都是代码

所有代码块都可以直接粘到编译器里执行，会报错的代码我都加了注释

(ง •_•)ง,加油

Python 语言基础

python规范

命名规则

必须以下划线或字母开头

前后单下划线为系统变量

双下划线开头为类的私有变量

关键字不能用作变量名

注释

单行注释以 # 开头

多行注释可用多个 # 或者用 三引号(文档注释)

多行语句

行尾使用反斜线(\)来续行

同一行写多条语句

语句间用分号(；)分隔

输入输出

输出print()

print默认在末尾换行

a = 1

b = 2

c = 3

# 直接输出多个变量

print(a,b,c) # 输出：1 2 3

# 使用 end参数用指定的字符替换末尾的换行符

print(a,end='@') # 输出：1@

# 使用format

print('a={}'.format(a))# 输出：a=1

print('a={0},b={1},c{2}'.format(a,b,c))# 输出：a=1,b=2,c3

输入input()

input输入的始终是字符串，需要转换为其他数据类型使用

python 数据类型

六个标准数据类型

Number(数字)

String(字符串)

List(列表)

Tuple(元组)

Sets(集合)

Dictionary(字典)

Number

包括：int(整型)、float(浮点型)、bool(布尔型)、complex(复数)、long(长整型)

清楚哪些值转换为布尔类型后值是False

print(bool([])) # 输出：False

print(bool('')) # 输出：False

print(bool({})) # 输出：False

print(bool(())) # 输出：False

# 注意下面两个的区别

print(bool(0)) # 输出：False

print(bool('0')) # 输出：True

浮点数的内置函数运算会有误差，也就是小数的精度问题

String

字符串属于序列，除此之外还有：元组、列表(集合和字典不是序列类型)

单引号和双引号可以互换，也可以互嵌

三引号表示多行字符串(也可以作为文档注释)

另外：三引号内可以直接使用回车、制表符，可以不使用转移字符来表示

字符串常用操作

连接和重复

print(‘hello’*3,’ wor’+’ld’) # 输出：hellohellohello world

字符串的切片(左闭右开)

word = 'hello world'

print(word[0:5]) # 输出：hello

print(word[:5]) # 输出：hello

print(word[1:]) # 输出：ello world

print(word[:]) # 输出：hello world

print(word[0:5:2]) # 输出：hlo

print(word[2:-2]) # 输出：llo wor

print(word[-2:2]) # 输出空串

转义字符

要注意这种复杂的转义字符一起输出

在字符串内的“\r”、”\t”、”\n”等字符，会转换为空白字符(回车符、水平制表符、换行符……)

printf('hello\tworld') # 输出：hello world

Raw字符串(字符串内不转义)

字符串前缀为’R’或‘r’

print(r‘hello\tworld’) # 输出：hello\tworld

变量及其赋值

简单赋值

a = 1

多目标赋值

a=b=c=1 # 这种情况下a、b、c都是引用同一个变量

这样会报错

a=(b=c=1) a=(b=1)

序列赋值

左边是元组、列表表示的多个变量，右侧是元组、列表或字符串等序列表示的值。

序列元素个数必须和变量个数相等，否则会出错

在变量名前使用“*”创建列表对象引用

a,b = 1,2 # 省略括号的元组赋值

(c,d) = (2,3) # 元组赋值

[e,f] = [4,’5’] # 列表赋值

(g,h) = [‘6’,7] # 元组和列表可以交叉赋值

(x,y,z) = ‘abc’ # 字符串赋值，x=‘a’,y=‘b’,z=‘c’

(i,j) = (8,9,10) # 这是错误的，变量和值的个数必须相等

在变量名前使用“*”创建列表对象引用

x,*y = ‘abcd’

print(x,y) # 输出：a [‘b’,’c’,’d’]

运算符和表达式

包括：算术运算符、关系运算符、字符串运算符、逻辑运算符。

算术运算符和表达式

算术运算符包括：加(+)、减(-)、乘(*)、除(/)、取余(%)、整除(//)、幂运算(**)

a+=1和a=a+1等价，a-=1、a//=2等也类似

要注意这种复杂的表达式的运算优先级

int(8 * math.sqrt(36) * 10 ** (-2) *10 + 0.5)/10

运算顺序如下：

int(8 * 6 * 10 ** (-2) * 10 + 0.5)/10

10**(2)=0.01

8 * 6 = 48

int(48 * 0.01 * 10 + 0.5 )/10

int(5.3)/10

5/10

0.5

逻辑运算符

and(逻辑与)，or(逻辑或)，not(逻辑非)

关系运算符

==(等于)、!=(不等于)、<>(不等于)、>(大于)、=(大于等于)、<=(小于等于)

运算符的优先级

最高优先级的三个运算符(优先级由高到低)：** 幂运算、~ 安位取反、- 负号

最低优先级的几个运算符(优先级由高到低)：| 按位或、< > <= >= == != 关系运算符、not and or逻辑运算符

字符串运算符

下面这些运算对于列表、元组都有效(因为它们同属序列类型)

字符串连接(+)

print('a'+'b') # 输出：ab

重复字符串(*)

print('a'*3) # 输出：aaa

索引字符串( [] )

a='hello'; print(a[1]); # 输出：e

截取字符串( [:] )

print(a[1:4]) # 输出：ell

成员运算符( in )

print('e' in a) # 输出：True

成员运算符( not in )

print('e' not in a) # 输出：False

Raw字符串( r/R )

print(R'he\tllo') # 输出：hello\nllo

格式字符串(%)

print('hello %s%s' %('wor','ld')) # 输出：hello world

格式化

%c(转换为字符)

print('%c' %('hello')) # 报错,必须是ASCII码值或者一个字符，否则会出错

%r(使用repr()进行字符串转换)

print('%r' %('hello')) # 输出：'hello'

%s(使用str()进行字符串转换)

print('%s' %('hello')) # 输出：hello

.format() 格式化

print('a={}'.format('a')) # 输出：a=a

repr()函数和str()函数的区别就在于接受值和返回值不同

repr()函数和str()函数，分别会调用输入对象的__repr__()、__str__()特殊方法

%d或%i(转换为有符号十进制数)

print(‘%d’ %(-10)) # 输出：-10

%u(转换为无符号十进制数)

print('%u' %(-10)) # 输出：-10

有无符号是指在二进制下，最高位用来表示实际的数或是单纯表示正负

%o(转换为无符号八进制数)

print('%o' %(100)) # 输出：144

%x或%X(转换为无符号十六进制数)

print('%x' %(100)) # 输出：64

%e或%E(转换成科学计数法)

print('%e' %(1000)) # 输出：1.000000e+03

%f或%F

print('%f' %(100) # 输出：100.000000)

格式化操作辅助符

print('开始%10.2f结束' %(7.2222)) # 输出：开始 7.22

%10.2f 表示：最小总长度为10，不足用前导空格补齐，长度大于等于10则正常显示(这里的长度不包括小数点)

位运算符

异或：二进制数逐位对比相同为0，不同为1

10^2==8 1010 异或 0010 结果为：1000

运算符

说明

&

按位与

|

按位或

^

按位异或

~

按位去反

<<

按位左移

>>

按位右移

python 常用函数

数据类型转换函数

重点掌握加粗的函数

函数名

说明

int(str)

将字符串str转换为整数

long(str)

将字符串str转换为长整型整数

float(str)

将字符串str转换为浮点数

eval(str)

将字符串str转换为有效表达式并返回表达式计算后的对象

str(x)

将数值x转换为字符串

repr(obj)

将对象obj转换为一个字符串

chr(x)

将整数x转换为对应的ASCII字符

ord(x)

将字符x转换为对应的ASCII码

hex(x)

将一个整数x转换为一个十六进制字符串

oct(x)

将一个整数x转换为一个八进制字符串

tuple(squ)

将一个序列squ转换为一个元组

list(squ)

将一个序列squ转换为列表

set(squ)

将一个序列squ转换为可变集合

dict(squ)

创建一个字典，squ是一个序列(key,value)元组

len(obj)

返回对象的长度(字符个数、列表元素个数、字典key个数)

数学函数

函数名

说明

abs(x)

返回数值x的绝对值

exp(x)

返回e的x次幂

fabs(x)

返回数字的绝对值

log10(x)

返回以10为底的x的对数

pow(x,y)

返回x的y次幂

floor(x)

x向下取整(小于等于x)

ceil(x)

x向上取整(大于等于x)

fmod(x,y)

求x/y的余数

sin(x) cos(x)...

返回x的三角函数值

python数据结构

python常用三种数据结构：序列、映射、集合

列表和元组有什么相同点和不同点？(后面会给出解释)

字符串

字符串是不可变的序列，不可以通过 str[n] = chr来改变字符串

字符串的切片(左闭右开)

word = 'hello world'

print(word[0:5]) # 输出：hello

print(word[:5]) # 输出：hello

print(word[1:]) # 输出：ello world

print(word[:]) # 输出：hello world

print(word[0:5:2]) # 输出：hlo

print(word[2:-2]) # 输出：llo wor

print(word[-2:2]) # 输出空串

字符串转列表

可以通过list()函数直接将字符串中的每个字符转换为一个列表元素，也可以通过split()方法根据指定的分割符分割元素(默认以空格分割)。

word = 'hello world'

print(list(word)) # 输出：['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

print(word.split()) # 输出：['hello', 'world']

列表转字符串

可以通过''.join()方法将字符串列表连接起来形成一个新的字符串

word = ['h','e','l','l','o']

words = ''.join(word)

print(words) # 输出：hello

字符串查找

可以通过in关键字查找也可以通过字符串的find()方法，in关键字返回True或False，find()方法返回查找字符串的开始下标或-1，通过index()方法查找当没有查找到时会报错。

word = 'hello world'

print('llo' in word) # 输出：True

print(word.find('llo')) # 输出：2

print('ok' in word) # 输出：False

print(word.find('0k')) # 输出：-1

print(word.index('ok')) # 报错

#带开始和结束范围的查找

print(word.find('llo',5,-1)) # 输出：-1

print(word.index('llo',0,5)) # 输出：2

字符串替换

replace()方法替换指定的字符串

str1 = 'hello world'

print(str1.replace('world','yznu')) # 输出：hello yznu

# 指定参数来限制替换的次数，不指定参数默认替换所有匹配的字符串

# 可以看到下面的语句只替换了一个l

print(str1.replace('l',' yes',1)) # 输出：he yeslo world

列表

列表的表示方法

[1,2,3,4]

创建列表

创建空列表、列表生成式、元组和字符串转列表

# 创建一个空列表

lst = []

# 直接将列表赋值给变量

lst = ['h','e','l','l','o']

# 元组转列表

lst = list((1,2,3,4))

print(lst) # 输出： [1,2,3,4]

# 字符串转列表

lst = list('hello')

print(lst) # 输出：['h','e','l','l','o']

# 字符串分割成列表

lst = 'hello world'.split()

print(lst) # 输出：['hello', 'world']

# range()生成列表

lst = list(range(1, 6))

print(lst) # 输出： [1,2,3,4,5]

# 列表生成式

lst = [x**2 for x in range(1,6)]

print(lst) # 输出： [1,4,9,16,25]

# 复杂列表生成式子

lst = [x for x in lst if x>1 and x<25]

print(lst) # 输出： [4,9,16]

列表元素删除

del(),pop(),remove()

# del 语句删除

lst = [1,2,3,4,5,6]

del(lst[5])

print(lst) # 输出： [1,2,3,4,5]

# pop 方法删除并返回指定下标的元素

print(lst.pop(4)) # 输出： 5

print(lst) # 输出： [1,2,3,4]

# remove 方法删除列表中的首次出现的某个值

lst.remove(4)

print(lst) # 输出： [1,2,3]

列表分片

使用[:]对列表分片和对字符串分片相同，列表还能分片赋值

# 列表分片赋值

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

lst[1:4] = [0,0,0] # 切片个数和赋值个数一样，否则报错

print(lst) # 输出： [1,0,0,0,5]

字符串转列表和列表转字符串

在上面字符串那一节已经写过，不再赘述，回到那里去看即可

列表常用的函数和方法

append(),count(),extend(),index(),sort(),len()

注意区别extend()和append()的用法

注意区别sort()和sorted()的用法

count()是非递归的统计一个元素出现的次数，也就是不会深入第二层

函数和方法

说 明

.append()

末尾追加一个元素(与.extend有何不同？)

.count()

统计某元素出现的次数(非递归式)

.extend()

以另一个序列的元素值去扩充原列表

.insert()

在指定下标处插入一个元素

.pop()

删除指定下标的元素并返回该元素

.reverse()

翻转列表

.sort()

对列表进行排序(与sorted函数有何不同？)

.index()

找到指定值第一次出现的下标(找不到报错)

.remove()

移除在列表中第一次出现的指定的值

len()

返回列表的元素个数

max()

返回最大值

min()

返回最小值

lst = [1,3,4,5]

# append 向列表中添加一个元素

lst.append([6,7])

print(lst) # 输出：[1, 3, 4, 5, [6, 7]]

# extend 用序列扩充列表

lst.extend([8,9,10])

print(lst) # 输出：[1, 3, 4, 5, [6, 7], 8, 9, 10]

# insert 方法在指定下标处插入一个值

lst.insert(1,2)

print(lst) # 输出：[1, 2, 3, 4, 5, [6, 7], 8, 9, 10]

# count 统计一个元素在列表中出现的次数

lst = [1,[2,3],2,3]

print(lst.count(2)) # 输出： 1

元组

元组的元素定义后不能修改

元组的表示方法

(1,2,3,4)

元组的创建

创建空元组、列表和字符串转元组

元组不能直接使用列表的方法排序(因为不可修改)

# 创建一个空元组

tup = ()

# 直接将元组赋值给变量

tup = (1,2,3)

# 列表转元组

tup = tuple([1,2,3]) # 输出：(1, 2, 3)

print(tup)

# 字符串转元组

tup = tuple('hello')

print(tup) # 输出：('h', 'e', 'l', 'l', 'o')

元组和列表的相同点和不同点

相同点

元组和列表都属于序列

元组和列表都支持相同操作符，包括 +(连接)、*(重复)、[]索引、[:]切片、in、not in等

不同点

元组是不可变的对象

对列表进行的修改元素的操作，在元组上不可以(列如del删除一个元组中的元素会出错，只能将整个元组删掉，不能只删某个元素)

字典

字典是映射类型

字典的key值必须是可哈希的(也可以说是不可修改的)

字典的表示方法

{key:value,key:value} {'name':'allen','age':18}

创建字典

创建空字典(使用空大括号默认创建字典，集合使用set())

fromkeys()创建字典、dict()创建字典

# 创建一个空字典

dict1 = {}

# 直接将字典赋值给变量

dict1 = {'one': 1, 'two': 2, 'three': 3}

print(dict1) # 输出：{'one': 1, 'two': 2, 'three': 3}

# dict创建字典(对比下面几种创建字典的形式吧)

#方式1

dict1 = dict(one=1, two=2, three=3) #这样创建字典，key不加引号

print(dict1) # 输出：{'one': 1, 'two': 2, 'three': 3}

#方式2

temp = [('two',2), ('one',1), ('three',3)]

dict1 = dict(temp)

print(dict1) # 输出：{'two': 2, 'one': 1, 'three': 3}

#方式3

temp = [['two',2], ['one',1], ['three',3]]

dict1 = dict(temp)

print(dict1)# 输出：{'two': 2, 'one': 1, 'three': 3}

#方式4

temp = (['two',2], ['one',1], ['three',3])

dict1 = dict(temp)

print(dict1)# 输出：{'two': 2, 'one': 1, 'three': 3}

# 使用fromkeys创建字典

subject = ['Python', '操作系统', '计算机网络']

scores = dict.fromkeys(subject, 99)

print(scores) # 输出：{'Python': 99, '操作系统': 99, '计算机网络': 99}

字典常用函数和方法

dict(),values(),keys(),get(),clear(),pop(),in(),update(),copy()

注意区别get()和直接访问字典元素的区别

scores = {'Python': 99, '操作系统': 99, '计算机网络': 99}

#print(socores['大学英语']) # 这会报错，因为不存在'大学英语'这个键

print(scores.get('大学英语')) # 输出：None

# values返回字典的所有值

print(scores.values()) # 输出：dict_values([99, 99, 99])

# keys返回字典的所有键

print(scores.keys()) # 输出：dict_keys(['Python', '操作系统', '计算机网络'])

# items返回字典的所有键和值

print(scores.items()) # 输出：dict_items([('Python', 99), ('操作系统', 99), ('计算机网络', 99)])

# 使用keys遍历

for k in scores.keys():

print(k,end=' ');

# 输出： Python 操作系统 计算机网络

# 使用values遍历

for v in scores.values():

print(v,end=' ');

# 输出：99 99 99

# 使用items遍历

for k,v in scores.items():

print(k,v,end=';');

# 输出：Python 99;操作系统 99;计算机网络 99;

# in查询一个字典中是否包含指定键

print( 'Python' in scores) # 输出：True

print( '数据结构' in scores) # 输出：False

# update更新字典，如果包含相同的键将会覆盖原来的对应的那个键值

dict1 = {'语文':90,'数学':91}

scores.update(dict1)

print(scores) # 输出：{'Python': 99, '操作系统': 99, '计算机网络': 99, '语文': 90, '数学': 91}

# 删除字典元素

del(scores['语文'])

print(scores) # 输出：{'Python': 99, '操作系统': 99, '计算机网络': 99, '数学': 91}

scores.pop('数学')

print(scores) # 输出：{'Python': 99, '操作系统': 99, '计算机网络': 99}

# 清空字典

scores.clear()

print(scores) # 输出：{}

集合

集合的元素不会有重复，利用这个特性编程题中可以去重

集合内的元素只能是可哈希的数据类型(也可以说是不可修改的)，无法存储列表、字典、集合这些可变的数据类型

集合是无序的，所以每次输出时元素的排序顺序可能都不相同

创建集合

创建空集合不能直接用大括号，大括号默认创建空字典

将序列转为集合

# 创建一个空集合不能直接用大括号

set1 = set()

# 将集合直接赋值给变量

set1 = {'Python','计算机网络','操作系统'}

print(set1) # 输出：{'操作系统', '计算机网络', 'Python'}

# 列表转集合

set1 = set(['操作系统', '计算机网络', 'Python','操作系统'])

print(set1) # 输出：{'Python', '计算机网络', '操作系统'}

# 字符串转集合

set1 = set('操作系统')

print(set1) # 输出：{'系', '作', '操', '统'}

集合的一些操作

set1 = {'Python','计算机网络','操作系统'}

set2 = set(['语文','操作系统','计算机网络'])

# 集合中没有 + 的操作

# print(set1+set2) #这样会出错

# 差集(set1有但是set没有的元素)

print(set1 - set2) # 输出：{'Python'}

# 交集(set1和set2都有的元素)

print(set1 & set2) # 输出：{'操作系统','计算机网络'}

# 并集(set1和set2所有的元素)

print(set1 & set2) # 输出：{'语文', '操作系统', '计算机网络', 'Python'}

# 不同时包含于a和b的元素

print(set1 ^ set2)

集合的常用方法

set(),add(),update(),remove()

集合不支持用 del() 删除一个元素

set1 = set(['操作系统', '计算机网络', 'Python','操作系统'])

# add 向集合中添加一个元素

set1.add('语文')

print(set1) # 输出：{'语文', '计算机网络', '操作系统', 'Python'}

# remove 删除集合中一个元素

set1.remove('语文')

print(set1) # 输出：{'Python', '操作系统', '计算机网络'}

程序流程控制(记得语句后面的冒号:)

程序流程控制一定要注意语句后面的冒号和语句块之间的缩进

分支选择

单分支

if:

多分支

if:

……

elif:

……

else:

……

程序例子

# 判断一个人的身材是否正常

height = float(input("输入身高(米)："))

weight = float(input("输入体重(千克)："))

bmi = weight / (height * height) #计算BMI指数

if bmi<18.5:

print("BMI指数为："+str(bmi))

print("体重过轻")

elif bmi>=18.5 and bmi<24.9:

print("BMI指数为："+str(bmi))

print("正常范围，注意保持")

elif bmi>=24.9 and bmi<29.9:

print("BMI指数为："+str(bmi))

print("体重过重")

else:

print("BMI指数为："+str(bmi))

print("肥胖")

#输入身高(米)：1.7

#输入体重(千克)：55

#BMI指数为：19.031141868512112

#正常范围，注意保持

三目运算

max = a if a>b else b if为真max=a,否则max=b

a = int(input('请输入a：')) # 假设输入10

b = int(input('请输入b:')) # 假设输入15

if a>b:

max = a

else:

max = b

print(max) # 输出：15

max = a if a>b else b

print(max) # 输出：15

循环结构

while循环

while循环的格式

# 循环的初始化条件

num = 1

# 当 num 小于100时，会一直执行循环体

while num <= 100 :

print("num=", num)

# 迭代语句

num += 1

print("循环结束!")

for循环

for循环的格式

for循环遍历字典、集合、列表、字符串、元组

subjects = ['Python','操作系统','网络']

# 循环遍历列表1

for i in subjects:

print(i,end=' ') # 输出：Python 操作系统 网络

print(' ')

# 循环遍历列表2

for i in range(len(subjects)):

print(subjects[i],end=' ') # 输出：Python 操作系统 网络

print(' ')

# 遍历字符串，元组也类似，就不写了

# 循环遍历列表1 这种形式也可以用于 字典、集合，但 循环遍历列表2这种形式不行

# 集合不能使用索引(因为它是无序的)，所以使用set[i]这种形式输出会报错

# 字典必须用键去索引值，dict[key]这种形式

列表生成式

range()函数与for循环的使用

range函数的格式如下：

range(start， end， step)

start:计数从 start 开始。默认是从0开始。例如 range(5)等价于range(0， 5)

end:计数到end结束，但不包括 end 例如：range(0， 5) 是 0, 1, 2, 3, 4 没有5

step：步长，默认为1。例如：range(0， 5) 等价于 range(0, 5, 1)

# 列表生成式

lst = [x for x in range(2,11,2)]

print(lst) # 输出：[2, 4, 6, 8, 10]

lst = [x*2 for x in range(2,11,2)]

print(lst) # 输出：[4, 8, 12, 16, 20]

# 直接循环range函数

for i in range(2,11,2):

print(i,end=' ') # 输出：2 4 6 8 10

print(' ')

for i in range(11):

print(i,end=' ') # 输出：0 1 2 3 4 5 6 7 8 9 10

print(' ')

break 和 continue 关键字

# 输出1-50之间的偶数

# 循环的初始化条件

num = 1

while num <= 100 :

if(num > 50): # 当num>50跳出循环

break

if(num%2 != 0 ): # num为奇数跳过输出，直接加一进入下一次循环

num += 1

continue

print("num=", num)

# 迭代语句

num += 1

print("循环结束!")

Python函数和模块

函数

函数的定义

def 函数名():

函数体

return语句

return语句可以没有

函数的嵌套定义，python函数内是可以定义函数的

函数的参数

默认参数

默认参数应该放在必须参数后面，类似这样 def(a,b,c=1):

可变参数

形参定义形式为*second，second会在函数中被解析为一个元组

# 可变参数1

def print_str(first, *second):# first必须要指定一个参数，second可以指定0个或多个参数

print(first,end=' ')

print(second)

print_str('hello') # 输出：hello ()

print_str('hello','world') # 输出：hello ('world',)

print_str('hello','world','yznu') #输出： hello ('world', 'yznu')

形参定义形式为 **anything，anything会被解析为一个字典

# 可变参数2

def printStr(**anything):

print(anything)

printStr(Python = 99, 操作系统 = 99) # 输出：{'Python': 99, '操作系统': 99}

变量的作用范围

局部变量和全局变量的定义

函数外不能访问函数内的变量

全局变量和局部变量同名，默认访问局部变量

在函数内要想改变函数外的变量需要用global关键字

# 函数外部不能访问函数内的变量(局部变量)

def demo(name):

str1 = 'hello'# 局部变量

print(str1,name)

demo('sir') # 输出：hello sir

# print(str1) # 访问函数内的局部变量会出错

# print(name) # 访问函数内的局部变量会出错

# 全局变量和局部变量同名，默认访问局部变量

str1 = 'hi' # 全局变量

def demo(name):

str1 = 'hello' # 局部变量

print(str1,name)

demo('sir') # 输出：hello sir

print(st1) # 输出：hi

# 在函数内要想改变函数外的变量需要用 global 关键字

str1 = 'hi' # 全局变量

def demo(name):

global str1 # 下面,对str1的修改会影响到函数外部的全局变量 str1

str1 = 'hello' # 局部变量

print(str1,name)

demo('sir') # 输出：hello sir

print(st1) # 输出：hello

python模块

Python 模块就是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

python模块的几种导入方法

import 模块1，模块2 (导入一个或多个模块)

from 模块 import 函数或类 (导入模块内的部分函数或类)

from 模块 import * (导入模块下的所有东西)

Python面向对象

面向对象基础

面向对象的三个特性

封装性

继承性

多态性

类的定义

class Demo:

'''随便定义了一个类'''

# 下面定义了一个类属性

add = 'hello'

# 下面定义了一个实例方法

def say(self, content):

print(content)

文档字符串可以省略，类体中可以定义属性、方法

属性

类属性和实例属性的区别？

类属性为所有实例共享，可以通过类名调用和修改类变量。

实例属性为每个实例所独有，只能通过实例调用和修改。

私有属性

不能在类外部直接通过实例调用私有属性，可以通过实例方法调用和修改

以双下划线开头，但不以双下划线结尾的属性为私有属性

class Demo:

def __init__(self, word):

self.__word = word # __word就是一个私有属性

def print_str(self):

print(self.__word)

a = Demo('hello') # 创建了一个实例，将实例赋值给a

方法

在类外部不能调用私有方法

几种方法的定义、作用和区别

self和cls参数的用法

__init__()方法的使用

@classmethod 的使用

@staticmethod 的使用

__init()__和__new()__有什么区别？

__init__() 方法在初始化一个实例的时候调用。

__new__()方法是创建实例的时候调用。

创建实例在初始化之前

# __init__() 和 __new__()的示例

class Person(object):

def __init__(self, name):

print('实例初始化了',end=' ')

self.name = name

def __new__(cls, name):

print('实例创建了',end=' ')

return object.__new__(cls)

person = Person('Sir')

print(person.name)

#输出如下(输出没有三引号)

"""

实例创建了

实例初始化了

Sir

"""

实例方法

实例方法必须通过生成的实例调用

类方法

类下的实例对象都可以调用类方法

类方法可以使用类名直接调用，也可以使用实例对象来调用

静态方法

静态方法通过类直接调用，不需要创建对象，不会隐式传递self

类的继承

单继承

# 这就是一个简单的单继承示例，C继承A

class A(object):

def work(self):

print('A.work')

class C(A): # C继承了A

def work(self):

print('C.work')

多继承

在多继承下，调用一个方法，清楚该方法的继承走向，也就是重名时优先调用哪一个次之又调用哪个

# 多继承1

class A(object):

def work(self):

print('A.work')

class B(object):

def work(self):

print('B.work')

class C(A): # C继承了A

def work(self):

print('C.work')

class D(B): # D继承了B

def work(self):

print('D.work')

class E(D,C): # E继承了D和C

def work(self):

print('E.work')

e = E()

e.work() # 输出 E.work

# 多继承2

class A(object):

def work(self):

print('A.work')

class B(object):

def work(self):

print('B.work')

class C(A): # C继承了A

def work(self):

print('C.work')

class D(B): # D继承了B

def work(self):

print('D.work')

class E(D,C): # E继承了D和C，自身没有work方法

pass

e = E()

e.work() # 输出 D.work

# 多继承3

class A(object):

def work(self):

print('A.work')

class B(object):

def work(self):

print('B.work')

class C(A): # C继承了A

def work(self):

print('C.work')

class D(B): # D继承了B，自身没有work方法

pass

class E(D,C): # E继承了D和C，自身没有work方法

pass

e = E()

e.work() # 输出 B.work

# 多继承4

class A(object):

def work(self):

print('A.work')

class B(object):

pass

class C(A): # C继承了A

def work(self):

print('C.work')

class D(B): # D继承了B，自身没有work方法

pass

class E(D,C): # E继承了D和C，自身没有work方法

pass

e = E()

e.work() # 输出 C.work

# 多继承5

class A(object):

def work(self):

print('A.work')

class B(object):

pass

class C(A): # C继承了A，自身没有work方法

pass

class D(B): # D继承了B，自身没有work方法

pass

class E(D,C): # E继承了D和C，自身没有work方法

pass

e = E()

e.work() # 输出 A.work

E继承了D和C，D继承了B，C继承了A

上面程序的继承走向： E -> D -> B -> C -> A

也就是会先在E中找同名的方法，找到了就结束

如果没有找到再到D中找，找到了结束

类似，再到B中找，再到C中找，再到A中找

下面还有一个多继承的例子

E继承了D和C，D继承了A，C继承了A

继承走向： E -> D -> C -> A

附

需要掌握的一些操作

这道编程题需要掌握

给定一个字符串从中随机抽取一些字符组成新的字符串，要求组成的字符串中不能有重复字符，生成的字符串不能重复，一共可以生成多少个字符串。

我就不贴出我的代码来了，我怕我自己做的是错的

随机抽取

random.sample()

从一个序列中随机抽出指定数量的元素，并以列表形式返回

import random

str1 = 'abcde'

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

tuple1 = (1,2,3,4,5)

# 随机从字符串中抽取5个字符组成新的列表

rand_str = random.sample(str1, 5)

print(rand_str)

# 随机从列表中抽取5个元素组成新的列表

rand_lst = random.sample(lst,5)

print(rand_lst)

# 随机从元组中抽取5个元素组成新的列表

rand_tuple = random.sample(tuple1,5)

print(rand_tuple)

random.choice()

从一个序列中随机抽取一个元素

import random

str1 = 'abcde'

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

tuple1 = (1,2,3,4,5)

# 从字符串中随机抽取一个字符

a = random.choice(str1)

print(a)

# 从元组中随机抽取一个元素

a = random.choice(tuple1)

print(a)

去重

利用集合去重

set1 = set()

set1.add(1)

set1.add(2)

set1.add(3)

set1.add(1)

set1.add(2)

set1.add(3)

print(set1) # 输出：{1, 2, 3}

利用循环遍历列表去重

list1 = [2, 1, 3, 6, 2, 1]

temp = []

for i in list1:

if not i in temp:

temp.append(i)

print(temp) # 输出：[2, 1, 3, 6]

一些特殊的字符串判断操作

str1 = 'hello'

str2 = '1234'

str3 = 'hello1234'

str4 = '\n \t'

# 判断所有字符都是字母

print(str1.isalpha()) # 输出：True

# 判断所有字符都是数字

print(str2.isdigit()) # 输出：True

# 判读所有字符都是 数字或者字母

print(str3.isalnum()) # 输出：True

# 判断所有字符都是空白字符(不只是空格)

print(str4.isspace()) # 输出：True

字符串转字节

str1 = 'yznu'

print(str1) # 输出：yznu

# 下面的输出都是字节类型

# 第一种

print(b'yznu') # 输出：b'yznu'

# 第二种

str2 = bytes(str1, encoding='utf-8')

print(str2) # 输出：b'yznu'

# 第三种 注意：encode方法并不会将原来的字符串变为字节，而是重新复制一份字节

str2 = str1.encode('utf-8')

print(str2) # 输出：b'yznu'

字节转字符串

byte = b'yznu' # 这是字节

# 第一种

str1 = str(byte, encoding="utf-8")

print(str1) # 输出：yznu

# 第二种

str1 = bytes.decode(byte)

print(str1) # 输出：yznu

应该复习得差不多了吧，祝各位考试顺利！

新年快乐！[](￣▽￣)*