Python的基础知识
0、重点
1.输入、输出
#输出
print()
#输入 #默认输入的是 str
age=input('请输入数字') #age的输入类型为 ：str
age=int(age)
a=int(input("请输入数字"))
#文件读取
file=open('a.txt','r') #r是只读
print(file.readlines())
file.close()
一、基础知识
类型查看：type(a)
#1.列表
lst[1,'hello']
lst1=list() #空
lst=[]
#2.字典
scores={'张三':100,'李四':98,'王五':45}
print(scores) #{'张三': 100, '李四': 98, '王五': 45}
print(scores['张三']) #输出：100
d={}
d1=dict()
#3.元组:小括号
t=('python',60,'hello')
t1=(9,)
t2=()
t3=tuple()
#4.集合
s={1,2,3,4,5,5,6,7,7}
print(s) #输出：{1, 2, 3, 4, 5, 6, 7}
1.输出函数：print（）
#1.输出数字
print(520)
#2.输出字符串 （单引号和双引号,三引号都可以）
#单引号和双引号定义的宇符串必须在一行，三引号定义的字符串可以分布在连续的多行
print('hello') #单引号
print("hello") #双引号
str4=“人生苦短
我用Python”
#3.含有运算符的表达式
print(3+1) #输出：4
#4.将数据输出文件中 (注意，1.使用file=fp)
fp=open('D:/shuju/Demo/wenjian/text.txt','a+')
print('hello',file=fp)
fp.close()
#5。输出在一行
print("hello","world",'nihao')
#6.
name='张三'
age=15
# print('我叫'+name+'今年，'+age+'岁') # 错误，解决方案，进行类型转换
print('我叫'+name+'今年，'+str(age)+'岁')
2.转义字符
| \n | 换行 |
| \t | 水平制表符 |
| \r | 回车、 |
| \b | 退路，回退一个字符 |
| \ | 转义字符 |
| r | 使用原字符 |
print('hello\\world') #输出hello\world
#r原字符(最后一个字符不能是\,但可以是print(r'hello\world\\') )
print(r'hello\world') #输出的是hello\world
3.Python中的标识符和保留字
1.标识符
（1）标识符是由字符（A~Z 和 a~z）、下划线和数字组成，但第一个字符不能是数字；
2.保留字
4.变量的定义和使用
1.变量由三部分组成：标识、类型、值
2.当多次赋值以后，变量名会指向新的空间
name="玛丽"
print(name)
5.数据类型
1.常见的数据类型
- 整数类型 int
- 浮点类型 float
- 布尔类型 bool True,False
- 字符串类型 str
2.数据类型转换
a=15
b="zhangsan"
c=True
str(a) a="15"
6.注释
# 1.单行注释
'''
2.多行注释
'''
二、函数、运算符、优先级
1.输入函数 input()
1.介绍
- 作用：接受来自用户的输入
- 返回值类型：输入值得类型为 str
- 值的存储：使用=对输入的值进行存储
a=input("你想要输入什么数字") #输入5
print(a,type(a)) # 输出 ：5 <class 'str'>
a=int(a)
print(a,type(a)) # 输出 ：5 <class 'int'>
a=int(input("你想要输入什么数字")) #输入5
2.运算符
1.算术运算符
print(11/2) #输出：5.5 #除法运算
print(11//5) #输出：5 #整除运算
print(11%5) #取余运算 #输出：1
print(3**2) #代表：3的2次方
print(9//-4) #一正一负，向下取余 输出：-3
print(9%-4) #
2.赋值运算符（从右到左）
-
支持链式赋值：a=b=c=d=2
# += -= *= /= //= %= a+=b #相当于a=a+b a,b,c=20,30,40
3.比较运算符
# >, <, >=, <=, !=(不等于)， ==(是否相等，是为1)
#比较对象标识使用：is is not
#比较运算符，的结果是bool类型的
a,b=10,20
print('a>10吗？',a>b) #输出：a>10吗？ False
#2.
a=10
b=10
print(a==b) #输出：True
print(a is b) #输出：True
#3.
lst1=[11,22,33,44]
lst2=[11,22,33,44]
print(lst1==lst2) #比较的是value的值 输出：True
print(lst1 is lst2) #比较的是id的值 输出：False
4.布尔运算符
-
and or not in not in
f=True f2=False print(not f) #False #in与not in s=('helloworld') print('w' in s) #s中有没有w的存在， 输出： print('k' in s) #输出：False print('k' not in s) #输出：True
5.位运算符
&：按位 与 ，相同为1，不同为0
| ：按位或 ，只有同为0时才为0
6.运算符的优先级
三、结构
1.程序的组织结构
1.顺序结构
2.选择结构（if)
3.循环结构（while、for-in）
2.顺序结构
3.选择结构
1.语法结构
**if 条件表达式1: **
? 条件执行体1
elif 条件表达式2:
? 条件执行体2
elif 条件表达式3:
? 条件执行体3
else:
? 条件执行体4
a=int(input('请输入成绩'))
if a>=90 and a<=100:
print("A")
elif a>=80 and a<90:
print("B")
elif a>=70 and a<80:
print("C")
elif a>=60 and a<70:
print("D")
elif a>100 and a<0:
print("成绩有误")
else:
print("E")
2.pass直接通过
a=int(input('输入：'))
if a>10:
pass
else
pass
4.循环结构
（1）while循环
1.语法结构
while 条件表达式:
? 条件执行体（循环体）
a=1
while a<10:
print(a)
a+=1
(2)for-in 循环
1.语法结构
for 自定义的变量 in 可迭代对象:
? 条件执行体（循环体）
b='item'
for a in b: #依次从b中一个个取出进行遍历
print(a)
for a in 'item': #第一次取出i，第二次取出t，第三次e，第四次m，结束
print(a)
for _ in range(5):
print("人生苦短") #输出：人生苦短5遍
for
（3）break和continue
if a>100:
break
while a<10:
if a>5:
break #break后同时跳出if和while循环
#continue语句：用于结束当前循环，进入下一次循环
#输出所有5的倍数
for item in range(1,51):
if item%5!=0:
continue
print(item)
(4)else与for、while的搭配使用
1.for、while循环结束完以后，在执行else（在没碰到break），碰到break，就不用执行else
5.内置函数（range函数的使用）
1.range( )的三种创建方式
（1）只有一个参数（小括号中只给了一个数）
r=range(10) #[0,1,2,3,4,5,6,7,8,9],默认从0开始
print(r) #输出：range(0, 10)
print(list(r)) #输出列表：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
（2）给两个参数
r=range(1,10) #[1,2,3,4,5,6,7,8,9],设置从1开始
（3）给了三个参数
r=range(1,10,2) #
print(list(r)) #输出列表：[1, 3, 5, 7, 9]
#判断10是否在r中
print(10 in r
四、列表
1.列表的创建 使用 [ ]
#创建列表的第一种方式
lst=['hello','world',98]
print(lst[0]) #输出：hello
print(lst[-3]) #输出：hello
#创建列表第二种方式，使用内置函数list()
lst2=list(['hello','world',987])
2.列表的查询操作
#获取索引
lst=['hello','world',98,'hello']
print(lst.index('hello')) #输出：0
print(lst.index('hello',1,4)) #输出：3, 索引指定位置，1,2,3这三个
#判断指定元素在列表中是否存在
lst=[10,20,'python','hello']
print(10 in lst) #判断10是否在列表lst中存在，输出：True
print(10 in lst) #输出：False
#列表元素的遍历
for item in lst:
print(item)
3.列表元素的增删改
3.1增 append( ) ,extend( ) ,insert ( ) ,切片
#向列表的末尾添加一个元素
lst=[10,20,30]
lst2=[40,50,60]
lst.append(100) #添加元素
print("添加元素之后",lst) #输出：添加元素之后 [10, 20, 30, 100]
#向列表的末尾添加一个元素
lst.append(lst2) #输出： [10, 20, 30, [40, 50, 60]]
#向列表的末尾添加一个列表
lst.extend(lst) #输出：[10, 20, 30, 10, 20, 30]
#指定位置添加一个数
lst.insert(1,90) #在1的位置添加90:输出：添加元素之后 [10, 90, 20, 30]
3.2 元素的删除
lst=[10,20,30,40,50,30]
#remove()的使用：指定元素
lst.remove(30) #输出：[10, 20, 40, 50, 30]
#pop（）的使用：指定索引数，如果不指定，则删除最后一个数
lst.pop(1) #输出：[10, 30, 40, 50, 30]
lst.pop() #输出：[10, 20, 30, 40, 50]
#切片
new_lst=lst[1:3] #输出：[20, 30]
lst[1:3]=[] #输出：[20, 30]
#清楚所有元素
lst.clear() #输出：[]
#删除列表
del lst
3.3 列表元素的修改
lst=[10,20,30,40,50,30]
#一次修改一个值
lst[2]=100 #输出：lst=[10,20,100,40,50,30]
#同时修改多个
lst[1:3]=[200,300,400] #相当于把lst原来[1,3)位置数删了，插入现在的
print(lst) #输出：[10, 200, 300, 400, 40, 50, 30]
3.4 列表排序
-
列表元素的排序操作
-
常见的两种方式
-
调用sort()方法，列有中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True进行降序排序
-
调用内置函数sorted()，可以指定reverse=True，进行降序排序，原列表不发生改变
-
-
lst=[10,20,30,40,50,8]
#排序，sort默认升序
lst.sort() #输出：[8, 10, 20, 30, 40, 50]
lst.sort(reverse=False)
#降序
lst.sort(reverse=True) #输出：[50, 40, 30, 20, 10, 8]
#内置函数排序
#升序
new_list=sorted(lst)
print(new_list)
#降序
new_list=sorted(lst,reverse=True)
print(new_list)
3.5 生成列表
lst=[i for i in range(1,10)]
print(lst) #[1, 2, 3, 4, 5, 6, 7, 8, 9]
lst=[i*i for i in range(1,10)]
print(lst) #[1, 4, 9, 16, 25, 36, 49, 64, 81]
五. 字典
1、字典的定义
- Python内置的数据结构之一，与列表一样是一个可变序列
- 以键值对的方式存储数据，字典是一个无序的序列
scores={'张三':100,'李四':98,'王五':45}
-
字典的实现原理
- 字典的实现原理与查字典类似，查字典是先根据部首或拼音查找应的页码,Python中的字典是根据key查找value所在的位置
2.字典的创建
scores={'张三':100,'李四':98,'王五':45}
print(scores) #{'张三': 100, '李四': 98, '王五': 45}
3.字典的常用操作
3.1字典中元素获取
scores={'张三':100,'李四':98,'王五':45}
#第一种方式
print(scores['张三']) #输出：100
#print(scores['张五']) #报错：KeyError: '张五'
#第二种方式 使用get()方法
print(scores.get('张三')) #输出：100
print(scores.get('张五')) #输出：None
3.2 key的判断、字典元素的删除、新增
scores={'张三':100,'李四':98,'王五':45}
print('张三' in scores) #True
print('张三' not in scores) #false
#删除
del scores['张三']
print(scores) #{'李四': 98, '王五': 45}
#清空
scores.clear() #{}
#新增
scores['礼拜']=90 #{'张三': 100, '李四': 98, '王五': 45, '礼拜': 90}
3.3 获取字典视图
scores={'张三':100,'李四':98,'王五':45}
#获取所有的key关键值
keys=scores.keys()
print(keys)
print(type(keys))
print(list(keys)) #将所有的key组成的视图转换成列表
#获取所有valu值
values=scores.values()
print(values)
print(type(values))
print(list(values))
#获取所有的key-values对
items=scores.items()
print(items)
print(type(items))
print(list(items)) #转换之后的列表元素是由元祖组成
#输出
'''
dict_keys(['张三', '李四', '王五'])
<class 'dict_keys'>
['张三', '李四', '王五']
dict_values([100, 98, 45])
<class 'dict_values'>
[100, 98, 45]
dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
<class 'dict_items'>
[('张三', 100), ('李四', 98), ('王五', 45)]
'''
3.4字典元素的遍历
scores={'张三':100,'李四':98,'王五':45}
for item in scores:
print(item)
'''
张三
李四
王五
'''
for item in scores:
print(item,scores[item],scores.get(item))
'''
张三 100 100
李四 98 98
王五 45 45
'''
3.5、内置函数生成字典
#内置函数生成字典
items=['a','b','c']
prices=[100,20,30]
#原字母
d={items:prices for items,prices in zip(items,prices)}
print(d) #{'a': 100, 'b': 20, 'c': 30}
#变大写
d={items.upper():prices for items,prices in zip(items,prices)}
#{'A': 100, 'B': 20, 'C': 30}
4、字典的总结
六、元组
1、元组的创建方式
2.元组的含义
3.元组的运用
1.元组中的元素是不可以修改的，但是元组中的列表可以修改
t=(10,[20,30,40],50)
print(t) #(10, [20, 30, 40], 50)
t[1].append(100) #(10, [20, 30, 40, 100], 50)
4.元组的遍历
t=(10,[20,30,40],50)
print(t[0]) #10
print(t[1]) #[20, 30, 40]
for item in t:
print(item)
'''
10
[20, 30, 40]
50
'''
七、集合
1.什么集合
2.集合的创建
#集合的创建方式
#第一种，使用{}
s={1,2,3,4,5,5,6,7,7}
print(s) #输出：{1, 2, 3, 4, 5, 6, 7}
#第二种，使用内置函数set()
s1=set(range(6))
print(s1) #{0, 1, 2, 3, 4, 5}
s2=set([1,2,3,4,4,4,5,5])
print(s2) #{1, 2, 3, 4, 5}
s3=set((1,2,3,858,65)) #集合中的元素是无序的
print(s3) #{65, 1, 2, 3, 858}
s4=set('python')
print(s4) #{'n', 'p', 'h', 'y', 'o', 't'}
s5=set({12,4,34,55})
print(s5) #{34, 12, 4, 55}
#定义空集合
# s6={} 这定义出来的不是空集合，而是dict，字典
s7=set()
3.集合的相关操作
3.1集合的判断操作
s={10,20,30,401,60}
print(10 in s) #True
print(80 in s) #False
print(10 not in s) #False
3.2 集合元素的新增操作
s={10,20,30,401,60}
#一次只能添加一个元素
s.add(800)
print(s) #{800, 401, 20, 10, 60, 30}
#添加多个元素
s.update({200,400,600}) #添加集合
s.update((1,2,3)) #添加元组
s.update([11,21,13]) #添加列表
3.3 集合元素的删除
#一次删除一个指定的元素，如果不存在抛出:KeyError
#s.remove(100)
s.remove(10) #{401, 20, 60, 30}
#一次删除一个指定的元素，如果不存在不抛出异常
#s.discard(100)
s.discard(10) #{401, 20, 60, 30}
#一次删除任意一个元素pop()
s.pop() #随机删除一个，并且pop()括号里不能添加参数
#清空集合
s.clear() #输出：set()
4.集合和集合之间的关系
4.1、集合是否相等
s1={10,20,30,40}
s2={20,10,40,30}
s3={1,2,3,4,5}
print(s1==s2) #True
print(s1!=s2) #False
print(s1==s3) #false
4.2、一个集合是否另一个集合子集
#s2是否是S1的子集
s1={10,20,30,40}
s2={20,10,40}
print(s2.issubset(s1)) #True
4.2、一个集合是否另一个集合超集
s1={10,20,30,40}
s2={20,10,40}
s3={1}
print(s1.issuperset(s2)) #True
print(s1.issuperset(s3)) #False
4.3 两个集合是否没有交集
s1={10,20,30,40}
s2={20,10,40}
s3={1}
print(s1.isdisjoint(s2)) #False (代表有交集）
print(s1.isdisjoint(s3)) #True (代表没有交集）
5.集合的操作
s1={10,20,30,40}
s2={20,10,40,50,60}
#交集
print(s1.intersection(s2)) #方法一
print(s1 & s2) #方法二
#并集
print(s1.union(s2)) #方法一
print(s1 | s2) #方法二
#差集
print(s1.difference(s2)) #方法一
print(s1 - s2) #方法二
#对称差集
print(s1.symmetric_difference(s2)) #方法一
print(s1 ^ s2) #方法二
6. 集合生成式
7. 元组和集合总结
八、字符串
1. 字符串的驻留机制
a='python'
b="python"
c='''python'''
print(a,id(a))
print(b,id(b))
print(c,id(c))
#输出
'''
python 2127053081200
python 2127053081200
python 2127053081200
'''
-
驻留机制的几种情况(交互模式)
- 字符串的长度为0或1时
- 符合标识符的字符串
- 字符串只在编译时进行驻留, 而非运行时
- [-5,256]之间的整数数字
-
sys中的intern方法强制2个字符串指向同一个对象
-
PyCharm对字符串进行了优化处理
-
字符串驻留机制的优缺点
- 当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，提升效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。
- 在需要进行字符串拼接时建议使用str类型的join方法，而非+ ,因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比"+"效率高
2.字符串的常用操作
2.1字符串的查询操作
s='hello,hello'
#查找子串第一次出现的位置,如果子串不存在时，则抛出ValueError
print(s.index('lo')) #输出：3
#查找子串后一次出现的位置，如果子串不存在时，则抛出ValueError
print(s.rindex('lo')) #输出：9
#查找子串第一次出现的位置,如果子串不存在时，则返回-1
print(s.find('lo')) #输出：3
#查找子串后一次出现的位置，如果子串不存在时，则抛出-1
print(s.rfind('lo')) #输出：9
2.2 字符串的大小写转换操作方法
a='hello,python'
#把所有字符串转换为大写
a=a.upper()
print(a) #输出：HELLO,PYTHON
#把所有字符串转换为小写
a1='HELLO,PYTHON'
a1=a1.lower()
print(a1) #输出：hello,python
#把字符串中所有大写字母转换成小写，小写转换成大写
a2='Hello,Python'
a2=a2.swapcase()
print(a2) #输出：hELLO,pYTHON
#把第一字字符转为大写，其余都为小写
a3='hello,Python'
a3=a3.capitalize()
print(a3) #输出：Hello,python
#把第一字字符转为大写，其余都为小写
a3='hello,Python,you,are very good'
a3=a3.title()
print(a3) #输出：Hello,Python,You,Are Very Good
2.3 字符串内容对齐操作方法
s='hello,python'
#居中对齐
print(s.center(20,'*')) #20是指定宽度 输出：****hello,python****
print(s.center(20)) #默认是空格 输出： hello,python
#左对齐
print(s.ljust(20,'*')) #hello,python********
print(s.ljust(15)) #hello,python
#右对齐
print(s.rjust(20,'*')) #输出：********hello,python
print(s.rjust(15)) #输出： hello,python
#右对齐，使用0填补
print(s.zfill(20)) #输出：00000000hello,python
2.4字符串的劈分
#默认分隔符是：空格
s='hello world Python'
lst=s.split() #默认分隔符是：空格
print(lst) #['hello', 'world', 'Python']
#默认分隔符是：空格,没有空格，不分割
s1='hello|world|Python'
lst1=s1.split() #默认分隔符是：空格,没有空格，不分割
print(lst1) #['hello|world|Python']
#指定分隔符
s1='hello|world|Python'
lst1=s1.split(sep='|')
print(lst1) #['hello', 'world', 'Python']
#指定分隔符sep='',指定最大分劈次数maxsplit
s1='hello|world|Python'
lst1=s1.split(sep='|',maxsplit=1)
print(lst1) #['hello', 'world|Python']
#rsplit从右侧开始分割
s='hello|world|Python'
lst=s.rsplit(sep='|',maxsplit=1) #默认分隔符是：空格
print(lst) #['hello|world', 'Python']
2.5判断字符串操作的方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dtOJ9R0T-1637664838180)(E:\markdown学习\python\图片\31.png)]
#判断是否是合法字符串
print(1,'hello'.isidentifier())
#判断是否全由空白字符组成
s.isspace()
#判断是否全由字母组成
s.isalpha()
#判断是否全是由十进制数字组成
s.isdecimal()
print('123四'.isdecimal()) #False
#判断是否全由数字组成
s.isnumeric()
print('123四'.isnumeric()) #true
#判断是否全由字符和数字组成
s.isalnum()
2.6 字符串的替换和合并
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3ksdgbrZ-1637664838181)(E:\markdown学习\python\图片\32.png)]
s='helo,python，python，python'
#替换，第一个被替换的，第二个替换的，第三个最大替换次数，默认全部替换
print(s.replace('python','JAVA')) #输出：helo,JAVA，JAVA，JAVA
print(s.replace('python','JAVA',2)) #输出：helo,JAVA，JAVA，python
#列表合并
lst=['hello','java','python']
print("|".join(lst)) #hello|java|python
print(''.join(lst)) #hellojavapython
#元组合并
t=('hello','java','python')
print(' '.join(t)) #hello java python
print('*'.join('python')) #p*y*t*h*o*n
3.字符串的比较操作
- 运算符: >, >=, <, <=, ==, !=
- 比较规则:首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
- 比较原理:两个字符进行比较时，比较的是其ordinal value(原始值),调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr,调用内置函数chr时指定ordinal value可以得到其对应的字符
#字符串的比较操作
print('applr'>'app') #True
print('applr'>'bann') #False(97>98)
print(ord('a')) #97
print(chr(97)) #a
4.字符串的切片操作
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6ROLNlN4-1637664838182)(E:\markdown学习\python\图片\33.png)]
s='hello.python'
s1=s[:5] #由于没有指定起始位置，所以从0开始
s2=s[6:] #python #由于没有指定结束位置，所以直接到最后一个字符
str=s1+'!'+s2
print(str) #hello!python
#完整的 (起始位置:结束位置:步长）
print(s[1:5:1]) #ello
print(s[0:5:2]) #hlo
5.格式化字符串
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3qLo7pdY-1637664838182)(E:\markdown学习\python\图片\34.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rt1n0b6B-1637664838182)(E:\markdown学习\python\图片\35.png)]
5.1.输出的形势
name='张三'
age=20
#方法一
print('我叫%s,今年%d岁'%(name,age)) #我叫张三,今年20岁
#方法二
print('我叫{0},今年{1}岁'.format(name,age))
#方法三
print(f'我叫{name},今年{age}岁')
5.2.宽度和精度
#表示宽度
print('%10d'% 90) #表示宽度为10
#表示精度
print('%f'% 3.1415926) #默认保留6位：3.141593
#保留三位小数
print('%.3f'% 3.1415926) #3.142
#同时表示宽度和保留小数位数
print('%10.3f'% 3.1415926) #3.142 #小数点前为：保留宽度； 小数点后：保留小数位数
#另一种
print('{0}'.format(3.1415926))
print('{0:.3}'.format(3.1415926)) #.3表示一共三位数，输出：3.14
print('{:.3f}'.format(3.1415926)) #.3表示一共三位小数，输出：3.142
print('{:10.3f}'.format(3.1415926)) #10表示宽度，.3表示一共三位小数，输出： 3.142
6. 字符串的编码转化
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g9bAYxay-1637664838183)(E:\markdown学习\python\图片\36.png)]
s='天天向上'
#编码
print(s.encode(encoding='GBK')) #在GBK这种编码格中，一个中文占两个字节
#输出：b'\xcc\xec\xcc\xec\xcf\xf2\xc9\xcf'
print(s.encode(encoding='UTF-8')) #在UTF-8这种编码格中，一个中文占三个字节
#输出：b'\xe5\xa4\xa9\xe5\xa4\xa9\xe5\x90\x91\xe4\xb8\x8a'
#解码
#byte代表就是一个二进制数据（字节类型的数据）
byte=s.encode(encoding='GBK') #编码
print(byte.decode(encoding='GBK')) #解码
7.总结
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jaBzK0o8-1637664838183)(E:\markdown学习\python\图片\37.png)]
九、函数
1.函数的创建和调用
-
什么是函数
函数就是执行特定任务和以完成特定功能的一段代码 -
为什么需要函数
- 复用代码
- 隐藏实现细节
- 提高可维护性
- 提高可读性便于调试·
-
函数的创建
def 函数名（[输入参数]) :
函数体
[return xxx] -
函数的调用
函数名([实际参数])
#函数的创建
def calc(a,b): #形参
c=a+b
return c
#函数的调用
a=calc(10,20) #实参
print(a)
2.函数的参数传递
-
位置实参
根据形参对应的位置进行实参传递[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aiQxrSR3-1637664838184)(E:\markdown学习\python\图片\38.png)]
-
关键字实参
根据形参名称进行实参传递[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SEX1HxDS-1637664838184)(E:\markdown学习\python\图片\39.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZEx2CNNq-1637664838185)(E:\markdown学习\python\图片\40.png)]
在函数调用过程中，进行参数的传递
? 如果是不可变对象，在函数体的修改不会影响实参的值，例如arg1修改为100，不会影响n1的值
? 如果是可变对象，在函数体的修改会影响实参的值，例如arg2的修改，append（10），会影响n2的值
def fun(arg1,arg2):
print("arg1",arg1)
print("arg2", arg2)
arg1=100
arg2.append(10)
print("arg1", arg1)
print("arg2", arg2)
n1=11
n2=[101,20]
fun(n1,n2)
print(n1)
print(n2)
#输出
'''
arg1 11
arg2 [101, 20]
arg1 100
arg2 [101, 20, 10]
11
[101, 20, 10]
'''
3.函数返回值
-
函数返回多个值时，结果为元组
函数的返回值
(1)如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】return可以省略不写(2)函数的返回值，如果是1个，直接返回类型
(3)函数的返回值，如果是多个，返回的结果为元组def fun(num): odd=[] #存奇数 even=[] #存偶数 for i in num: if i%2: odd.append(i) else: even.append(i) return odd,even #函数的调用 lst=[10,29,34,23,44,53,55] print(fun(lst)) #([29, 23, 53, 55], [10, 34, 44]) def fun1(): return 'helloi','world' print(fun1()) #('helloi', 'world')
4.函数的参数定义
- 函数定义默认值参数
函数定义时，给形参设置默认值，只有与默认值不符的时候才需要传递实参
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-My7o3X9x-1637664838185)(E:\markdown学习\python\图片\41.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X0DnfupH-1637664838186)(E:\markdown学习\python\图片\42.png)]
2.个数可变的位置参数（输出的是：元组）
def fun(*args): #函数定义时的，可变的位置参数
print(args)
print(args[0])
fun(10) #(10,) 10
fun(80,20) #(80, 20) 80
fun(150,20,50,50) #(150, 20, 50, 50) 150
3.个数可变的关键字形参 (输出的：字典)
def fun(**args): #函数定义时的，可变的位置参数
print(args)
fun(a=10) #{'a': 10}
fun(a=80,b=20) #{'a': 80, 'b': 20}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YzdjaBpJ-1637664838186)(E:\markdown学习\python\图片\43.png)]
4.1、函数的参数总结
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mUbgpQIu-1637664838187)(E:\markdown学习\python\图片\44.png)]
#函数的调用
fun(10,20,30) #函数调用是的参数传递，称为位置参数
#列表
lst=[11,22,33]
fun(*lst) #在函数调用时，将列表中的每个元素都转换成位置实参传入
fun(a=100,b=200,c=300) #函数的调用，所以是关键字实参
#字典
dic={'a':111,'b':222,'c':333}
fun(**dic) #在函数调用时，将字典中的键值对都转换成关键字实参传入
def fun(a,b,*,c,d): #从*之后的参数，在函数调用时，只能采用关键字参数传递
5.变量的作用域
- 程序代码能访问该变量的区域
- 根据变量的有效范围可分为
- 局部变量
在函数内定义并使用的变量，只在函数内部有效，局部变量使用global声明，这个变量就会就成全局变量 - 全局变量
函数体外定义的变量,可作用于函数内外
- 局部变量
name='小李' #name为全局变量
def fun6(a,b):
c=a+b #c为局部变量
print(c)
global age #使用global声明以后，age就是全局变量了
age=20
fun6(7,8)
print(age)
6.递归函数
-
什么是递归函数
如果在一个函数的函数体内调用了该函数本身，这个函数就称为递归函数 -
递归的组成部分
递归调用与递归终止条件 -
递归的调用过程
每递归调用一次函数，都会在栈内存分配一个栈帧,每执行完一次函数，都会释放相应的空间
-
递归的优缺点
缺点:占用内存多，效率低下优点:思路和代码简单
#6的阶乘
def fun(a):
if a==1:
return 1
else:
return a*fun(a-1)
print(fun(6))
7.函数总结
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x1SaVEG8-1637664838187)(E:\markdown学习\python\图片\45.png)]
十、Bug
1、Bug的由来及分类
1.1、常见类型
-
粗心导致的语法错误SyntaxError
1.输入类型默认为 str
-
粗心导致错误的自查宝典
1、漏了末尾的冒号，如if语句,循环语句,else子句等2、缩进错误，该缩进的没缩进，不该缩进的瞎缩进
3、把英文符号写成中文符号，比如说:引号，冒号，括号4、字符串拼接的时候，把字符串和数字拼在一起
5、没有**定义变量,**比如说while的循环条件的变量6、**"==”比较运算符和”=”**赋值运算符的混用
-
知识不熟练导致的错误
(1)索引越界问题IndexError```python lst=[11,22,33,44] print([4]) #越界 ```(2) append()方法的使用掌握不熟练
lst=[] ##lst=append ( ' A'，'B','C') 一次只能添加一个变量 lst.append("a") print (lst)
-
1.2常见的异常类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ibWrQFpP-1637664838188)(E:\markdown学习\python\图片\50.png)]
2、不同异常类型的处理方式和异常处理机制
捕获异常
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dwZRm0fA-1637664838188)(E:\markdown学习\python\图片\49.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6TRWcQUw-1637664838188)(E:\markdown学习\python\图片\46.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2kaYBh5A-1637664838189)(E:\markdown学习\python\图片\47.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tHOtrK3U-1637664838189)(E:\markdown学习\python\图片\48.png)]
-
traceback模块
使用traceback模块打印异常信息
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fuwfbmNC-1637664838190)(E:\markdown学习\python\图片\51.png)]
3、PyCharm的调试机制
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jPCZD9hB-1637664838190)(E:\markdown学习\python\图片\52.png)]
4、总结
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fLB3L48k-1637664838190)(E:\markdown学习\python\图片\53.png)]
十一、类和对象
1、两大编程思想
| 面向过程 | 面向对象 | |
|---|---|---|
| 区别 | 事物比较简单，可以用线性的思维去解决 | 事情比较复杂，使用简单的线性思维无法解决 |
| 共同点 | 面向过程和面向对象都是解决实际问题的一种思维方式 | |
| 二者相辅相成，并不是对立的解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间复杂的关系、方便我们分析整个系统; | 具体到微观操作，仍然使用面向过程方式来处理 |
2、类和对象的创建
-
类
类别,分门别类，物以类聚，人类，鸟类，动物类，植物类… -
类是多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质
-
数据类型
不同的数据类型属于不同的类使用内置函数查看数据类型
print(type (100)) <class ‘int’>
print(type (99)) <class ‘int’>
print(type(520)) <class int’> -
对象
100、99、520都是int类之下包含的相似的不同个例，这个个例专业数语称为实例或对象
2.1 类的创建
-
创建类的语法
clss Student: pass -
类的组成
- 类属性
- 实例方法
- 静态方法
- 类方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d9COnDlj-1637664838191)(E:\markdown学习\python\图片\54.png)]
class Student: #Student为类名，由一个或多个单词组成，每个单词的首字母大写，其余小写
native_pace='吉林' #直接写在类里的变量，称为类属性
def __init__(self,name,age):
self.name=name #self.name称为实体属性，进行了一个赋值的操作，将局部变量的name的值赋给实体属性
self.age=age
#实例方法
def eat(self):
print('')
#静态方法
@staticmethod
def method(): #静态方法中不允许写self
print('静态方法')
#类方法
@classmethod
def cm(cls):
print('类方法')
#在类之外定义的称为函数，在类之内定义的称为方法
def drink():
print("这就是函数")
#创建Student类的对象
stu1=Student('张三',20) #类的对象
stu1.eat() #对象名,方法名（）
print(stu1.name) #张三
print(stu1.age) #20
print("--------------------")
#类名.方法名（类的对象）
Student.eat(stu1) #与stu1.eat()的功能一样，都是调用Student中eat的方法
#类属性的使用方式
print(Student.native_pace)
stu2=Student('张三',20)
stu3=Student('李四',30)
print(stu2.native_pace)
print(stu3.native_pace)
Student.native_pace='天津'
print(stu2.native_pace)
print(stu3.native_pace)
print("-------类方法的使用-------------")
Student.cm()
print("-------静态方法的使用-------------")
Student.method()
2.2 对象的创建
-
对象的创建又称为类的实例化
-
语法: **实例名=类名() **
-
意义:有了实例,就可以调用类中的内容
-
例子
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PTkAqutG-1637664838191)(E:\markdown学习\python\图片\55.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mAcC7KfV-1637664838192)(E:\markdown学习\python\图片\56.png)]
3、类对象与类属性
- 类属性:类中方法外的变量称为类属性，被该类的所有对象所共享
- 类方法:使用@classmethod修饰的方法，使用类名直接访问的方法
- 静态方法:使用@staticmethod修饰的主法，使用类名直接访问的方法
print(Student.native_place) #访问类属性
Student.cm() #调用类方法
Student.sm() #调用静态方法
4、类方法与静态方法
4.1 动态绑定属性和方法
- Python是动态语言，在创建对象之后，可以动态地绑定属性和方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-szr6ZwI8-1637664838192)(E:\markdown学习\python\图片\57.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hJ7zxYcw-1637664838192)(E:\markdown学习\python\图片\58.png)]
class Student:
def __init__(self,name,age):
self.name=name
self.age=age
def eat(self):
print(self.name+'在吃饭')
stu1=Student('张三',20)
stu2=Student('李四',30)
print('------为stu2动态绑定性别属性----------')
stu2.gender='女'
print(stu1.name,stu1.age)
print(stu2.name,stu2.age,stu2.gender) #李四 30 女
print('----------------')
stu1.eat()
stu2.eat()
def show():
print('定义在类之外的，称为函数')
stu1.show=show
stu1.show()
5、总结
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-59KvtiSF-1637664838193)(E:\markdown学习\python\图片\59.png)]
两种调用方式
stu=Student
#第一种
stu.eat()
#第二种
Student.eat(stu)
十二、面向对象的特征（封装、继承、多态）
1、封装
1.1面向对象的三大特征
-
**封装:**提高程序的安全性
- 将数据（属性）和行为(方法)包装到类对象中。在方法内部对属性进行操作，在
类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。 - 在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个"_”。
- 将数据（属性）和行为(方法)包装到类对象中。在方法内部对属性进行操作，在
-
继承:提高代码的复用性
-
多态:提高程序的可扩展性和可维护性
1.封装
class Student: def __init__(self,name,age): self.name=name self.__age=age #在类的外部不可以被使用,但在类的内部可以使用 def show(self): print(self.name,self.__age) stu=Student('张三',20) stu.show() #张三 20 #在类的外使用name与age print(stu.name) #print(stu.__age) #这样不可以直接使用 print(stu._Student__age) #在类的外部可以通过_Student__age进行访问
2、继承
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WSIY1ejf-1637664838193)(E:\markdown学习\python\图片\60.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YK1SR7dy-1637664838194)(E:\markdown学习\python\图片\61.png)]
#多继承
class A(object):
pass
class B(object):
pass
class C(A,B):
pass
3、方法重写
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KptcK87i-1637664838194)(E:\markdown学习\python\图片\62.png)]
4、object类
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-btXOja60-1637664838194)(E:\markdown学习\python\图片\63.png)]
5、多态
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HPbdIySj-1637664838195)(E:\markdown学习\python\图片\64.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S0nHGX0n-1637664838195)(E:\markdown学习\python\图片\65.png)]
6、特殊方法和特殊属性
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HYLT1Ze8-1637664838196)(E:\markdown学习\python\图片\66.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o9vK8du0-1637664838196)(E:\markdown学习\python\图片\68.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-heSz97N3-1637664838199)(E:\markdown学习\python\图片\69.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wtPsL8BP-1637664838199)(E:\markdown学习\python\图片\70.png)]
十三、类的赋值与浅拷贝
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9h0n7E4d-1637664838200)(E:\markdown学习\python\图片\72.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3OVdaHKN-1637664838200)(E:\markdown学习\python\图片\71.png)]
十四、模块
1.什么是模块
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QAZnBX0y-1637664838200)(E:\markdown学习\python\图片\73.png)]
2.模块的导入（自定义模块）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TzeqqyNL-1637664838201)(file:///C:\Users\hp\AppData\Roaming\Tencent\Users\943234357\QQ\WinTemp\RichOle\IQO`2FF06FMCH9X26~C70[E.png)]
import math #关于数学的模块
print (math.pi)
#导入模块中指定的
from math import pi
3.以主程序形式运行
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vLHQxt0e-1637664838201)(C:\Users\hp\AppData\Roaming\Typora\typora-user-images\image-20211111210528147.png)]
4.python中的包
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hCje3ewH-1637664838202)(C:\Users\hp\AppData\Roaming\Typora\typora-user-images\image-20211111211032959.png)]
import 包名.模块名 as 别名 #把 名.模块名 改为一个好写的 别名
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DyIA1jvG-1637664838202)(C:\Users\hp\AppData\Roaming\Typora\typora-user-images\image-20211111211727322.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mu4Gxat7-1637664838202)(E:\markdown学习\python\图片\74.png)]
5、python中常用的内置模块
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NMgNFDSN-1637664838203)(E:\markdown学习\python\图片\75.png)]
6.第三方模块的安装及使用
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yj4NJFje-1637664838203)(E:\markdown学习\python\图片\76.png)]
7、总结
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fmSbygMx-1637664838203)(E:\markdown学习\python\图片\77.png)]
十五、文件
1、编码格式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u0YZ1p2v-1637664838204)(E:\markdown学习\python\图片\78.png)]
2、文件读写原理
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UelcRkyg-1637664838204)(E:\markdown学习\python\图片\79.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-by0fySRx-1637664838205)(E:\markdown学习\python\图片\80.png)]
3.常用的文件打开模式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wSjM1eVL-1637664838205)(E:\markdown学习\python\图片\81.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8No9NwHP-1637664838205)(E:\markdown学习\python\图片\82.png)]
4.文件对象的常用方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-84yMq4iq-1637664838206)(E:\markdown学习\python\图片\83.png)]
5.with语句
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QBYnrkcP-1637664838206)(E:\markdown学习\python\图片\84.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xXAEzcGH-1637664838206)(E:\markdown学习\python\图片\85.png)]
6、os模块
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gJVxcQdU-1637664838207)(E:\markdown学习\python\图片\86.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1ZGUDsX6-1637664838207)(E:\markdown学习\python\图片\87.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ExnpjFMY-1637664838208)(E:\markdown学习\python\图片\88.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-soBvi0Do-1637664838209)(E:\markdown学习\python\图片\89.png)]