Python学习笔记
Python学习第一天
DAY1:
1.1 基础知识
1、print输出函数
# print函数
# 输出数字
print(520)
print(98.5)
# 输出字符串
print('hello')
print("hello")
# 输出含有运算符的表达式
print(1+2)
# 将数据输出到文件中 注意点:使用file=fp
fp = open('D:/text.txt', 'a+') # 如果文件不存在就创建,存在就在文件的内容后面继续追加
print('helloworld', file=fp)
fp.close()
# 不进行换行输出
print('hello', 'world', 'Python')
2、转义字符与原字符
# 转义字符
print('hello\nworld') # 换行
print('hello\tworld') # TAB
print('helloooo\tworld')
print('hello\rworld') # 覆盖 world
print('hello\bworld') # 退一个格子 hellworld
# 原字符:不希望字符串的转义字符起作用,就使用原字符,就是在字符串之前加上r,或者R
print(r'hello\nworld')
# 注意事项,最后一个字符串不能是反斜杠
1.2 变量
# 变量的定义和使用
name='玛利亚'
print('标识',id (name)) # 标识 2188804497008
print('类型',type(name)) # 类型 <class 'str'>
print('值',name) # 值 玛利亚
# 变量多次赋值,指向新的空间
name='玛利亚'
name='褚柳兵'
print(name)
1.3 注释
1.4 数据类型
1、整型:int~~可表示二进制、十进制、八进制、十六进制,默认十进制
二进制0b
八进制0o
十六进制0x
2、浮点类型:float~~解决精度问题
#解决精度问题
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))
3、布尔类型:可以转成整数类型参与计算
#布尔类型:可以转成整数计算
print(True+1) # 2
print(False+1) # 1
4、字符串类型:可使用单引号,双引号,三引号,其中三引号可实现换行
1.5 类型转换
# str()将其他类型转换为str类型
# int()将其他类型转换为int类型
# 将str字符串只能是整数数字串,不能是小数串,非数字串
# 将float类型转换为int,会截取摄取
# float()将其他类型转换为float类型
# 字符串中的数据如果是非字符串则不能进行转换
1.6 input函数
# input输入函数 输入的数据为字符串类型
a =int(input('请输入一个加数:'))
b =int(input('请输入另一个加数:'))
print('结果为'+str(a+b))
1.7 运算符
1、算术运算符
# 算术运算符
# 加法:+ 减法:- 乘法:* 除法:/ 整除://
print(11/5) #2.2
print(11//5) #2
print(9//-4) #-3
print(-9//4) #-3 一正一负整数公式,向下取整
# 取余:%
# 幂运算:**
print(2**3) #8
2、赋值运算符
# 赋值运算符
# 链式赋值
a=b=c=20
print(a,id(a)) # 20 140725320534272
print(b,id(b)) # 20 140725320534272
print(c,id(c)) # 20 140725320534272
# 参数赋值
# += -= *= /= //= %=
# 支持系列解包赋值
a,b,c=20,30,40 #左右两边数目相等
print(a,b,c) #20,30,40
# 可用作数字交换
a,b=10,20 #a=10 b=20
print('交换前:',a,b)
a,b=b,a #a=20 b=10
print('交换后:',a,b)
3、比较运算符~~输出结果为布尔类型
# >,<,>=,<=,!=
# ==比较值
# is,is not比较标识id
4、布尔运算符
# and~~并且 当两个运算数都为True时,结果为True
# or~~或者 当只有一个运算数都为True时,结果为True
# not~~非 当运算数都为True时,结果为False
# in 是否在其中间
print('w' in 'hellowprld') #True
# not in
5、位运算符 >>,<< -> & -> I
# 位与& 对应位数都是1,结果位数才位1,否则为0
# 位或| 对应位数都是0,结果位数才位0,否则为1
# 左移位运算符<< 高位溢出舍弃,低位补0
# 右移位运算符>> 低位溢出舍弃,高位补0
6、运算符优先级
算术运算->位运算->比较远算符->布尔运算->赋值运算
DAY2
2.1 程序的组织结构
1、顺序结构
2、选择结构
(1)对象的布尔值:Python一切皆对象,所有对象都有一个布尔值,使用bool()函数获取
以下对象的布尔值为False:False,数值0,None,空字符串,空列表,空元组,空字典,空集合
(2)分支结构
# 分支结构
#单分支结构
money=1000
s=int(input('请你输入你要取的钱:'))
if money>=s :
print('取钱成功')
#双分支结构
a=int(input('请你从键盘输入一个整数:'))
if a%2 :
print('这个数是奇数')
else :
print('这个数是偶数')
#多分支结构
score=int(input('请输入一个成绩'))
if 90 <= score <= 100 : #PY独有写法
print('A级')
elif 80 <= score <= 89 :
print('B级')
elif 70 <= score <= 79:
print('C级')
elif score >= 60 and score <= 69:
print('D级')
elif score >= 0 and score <= 59:
print('E级')
else :
print('对不起,成绩有误,不在成绩的有效范围')
(3)条件表达式
(4)pass语句
# pass语句,什么都不做,只是一个占位符,用到需要写语句的地方
answer=input('您是会员吗?y/n')
#判断是否是会员
if answer=='y' :
pass
else :
pass
3、循环结构
(1)range函数
# range()的三种创建方式
# 第一种方式,只有一个参数,步长为1,默认从0开始,到10结束(不包含10)
r=range(10)
print(r) #range(0, 10)
print(list(r)) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#第二种方式,给了两个参数,步长为1,指定从1开始,到10结束(不包含10)
r=range(1,10)
print(r) #range(1, 10)
print(list(r)) #[1, 2, 3, 4, 5, 6, 7, 8, 9]
#第三种方式,给了三个参数,指定步长为2,指定从1开始,到10结束(不包含10)
r=range(1,10,2)
print(r) #range(1, 10, 2)
print(list(r)) #[1, 3, 5, 7, 9]
#判断指定的整数在序列中是否存在 in,not in
print(10 in r) #False
print(9 in r) #True
print(10 not in r) #True
print(9 not in r) #False
(2)while循环
# while 循环
'''初始化变量'''
a=0
'''条件判断'''
while a<=10 :
'''条件执行体(循环体)'''
print(a)
'''改变变量'''
a+=1
(3)for-in循环
# for-in循环
for item in 'Python' : #第一次取出来的是P,将P赋值给item,将item输出
print(item)
#range()产生一个整数序列,--》也是一个可迭代对象
for i in range(5) :
print(i)
#如果在循环体中不需要使用自定义变量,可将自定义变量写为“_”
for _ in range(5) :
print('人生苦短,我用Python')
#计算1-100的偶数和
sum =0
for a in range(0,101,2) :
sum+=a
print(sum)
(4)else语句
# else语句
# 与if一起使用,如果if条件表达式不成立时执行else
# 与while,for一起使用,如果没有碰到break是执行else
a=0
while a<3 :
pwd=input('请输入密码')
if pwd=='8888' :
print('密码正确')
break
else :
print('密码不正确')
a+=1
else :
print('对不起,三次密码均输入错误')
2.2 列表
(1)列表的创建
# 列表的创建
# 方法1:使用[]
lst = ['hello','world',98]
# 方法2;使用list()
lst2 =list(['hello','world',98])
# 列表生成式
lst2=[ i*2 for i in range(1,11)]
print(lst2) #[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
(2)列表的特点
①列表元素按顺序有序排列
②索引映射唯一数据
③列表可以存储重复数据
④任意数据类型混存
⑤根据需要动态分配和回收内存
(3)获取
# 获取列表索引
lst = ['hello','world',98,'hello']
print(lst.index('hello')) #如果列表中有相同元素只返回相同元素的第一个 0
print(lst.index('hello',1,4)) #指定查找范围 3
# 获取列表中单个元素
print(lst[2]) #98 正向索引
print(lst[-1]) #hello 逆向索引
# 获取列表中多个元素
lst2=[10,20,30,40,50,60,70,80]
#start=1 ,stop=6, step=1
print(lst2[1:6:1]) #切片出来的是一个新的列表 [20, 30, 40, 50, 60]
#默认步长为1,默认start=0,默认stop为最后
print(lst2[:6:]) #[10, 20, 30, 40, 50, 60]
print(lst2[1::]) #[20, 30, 40, 50, 60, 70, 80]
#step为负数时,第一个元素为原列表的最后一个元素
print(lst2[::-1]) #[80, 70, 60, 50, 40, 30, 20, 10]
(4)查询
①in或者not in
②for-in遍历
(5)增加
①append():在列表末尾添加一个元素
②extend():在列表末尾至少添加一个元素
③insert():在列表任意位置插入一个元素
④切片:在列表任意位置插入至少一个元素
(6)删除
# 列表的删除
# remove
lst=[10,20,30,40,50,60,30]
lst.remove(30) #从列表中移除一个元素,若有重复元素,只移除第一个元素
print(lst) #[10, 20, 40, 50, 60, 30]
# pop 根据索引移除元素,若未指定则删除最后一个元素
lst.pop(1)
print(lst) #[10, 40, 50, 60, 30]
lst.pop()
print(lst) #[10, 40, 50, 60]
#切片:删除至少一个元素,但是将产生一个新的列表对象
new_lst=lst[1:3]
print('原列表',lst) #原列表 [10, 40, 50, 60]
print('切片后的列表',new_lst) #切片后的列表 [40, 50]
#不产生新的列表,而是删除列表中的内容
lst[1:3]=[]
print('切片后的列表',lst) #切片后的列表 [10, 60]
# clear 清除列表中所有元素
# del 将列表删除
(7)修改
# 列表的修改
lst=[10,20,30,40,50]
# 一次修改一个值
lst[2]=100
print(lst) #[10, 20, 100, 40, 50]
# 一次修改多个值
lst[1:3]=[300,400,500]
print(lst) #[10, 300, 400, 500, 40, 50]
(8)排序
# 列表的排序
# sort ,升序排序
lst=[10,20,40,50,30]
print('排序前的列表',lst,id(lst)) #排序前的列表 [10, 20, 40, 50, 30] 2849276617600
lst.sort()
print('排序后的列表',lst,id(lst)) #升序 排序后的列表 [10, 20, 30, 40, 50] 2849276617600
#通过指定关键字,将列表中的元素进行降序排序
lst.sort(reverse=True)
print('排序后的列表',lst,id(lst)) #降序 排序后的列表 [50, 40, 30, 20, 10] 2849276617600
lst.sort(reverse=False)
print('排序后的列表',lst,id(lst)) #升序 排序后的列表 [10, 20, 30, 40, 50] 2849276617600
# sorted用法和上面差不多,但会产生一个新的列表
DAY3:
3.1 字典
(1)字典的创建
# 字典的创建
# 方法一
scores={'张三':100,'李四':98,'王五':45}
print(scores) #{'张三': 100, '李四': 98, '王五': 45}
print(type(scores)) #<class 'dict'>
#方法二
student=dict(name='jack',age=18)
print(student) #{'name': 'jack', 'age': 18}
#空字典
d={}
print(d) #{}
d1=dict()
print(d1) #{}
#字典生成式 zip过程以元素少的为准
items=['Fruits','Books','Others']
prices=[96,78,85,100]
d2={item:price for item,price in zip(items,prices)} #{'Fruits': 96, 'Books': 78, 'Others': 85}
print(d2)
d3={item.upper():price for item,price in zip(items,prices)} #{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}
print(d3)
(2)字典元素的获取
# 字典元素的获取
#方法一:
scores={'张三':100,'李四':98,'王五':45}
print(scores['张三']) #100
#print(scores['李六']) #KeyError: '李六'
#方法二:
print(scores.get('张三')) #100
print(scores.get('李六')) #None
print(scores.get('李六',99)) #99
(3)增删改查
# Key键的判断
scores={'张三':100,'李四':98,'王五':45}
print('张三' in scores) #True
print('张三' not in scores) #False
# 删除指定的key-value对
del scores['张三']
print(scores) #{'李四': 98, '王五': 45}
# 清空字典元素
scores.clear()
print(scores) #{}
# 新增元素
scores['陈六']=98
print(scores) #{'陈六': 98}
# 修改元素
scores['陈六']=100
print(scores) #{'陈六': 100}
(4)字典的视图操作
# 获取所有的键key
keys=scores.keys()
print(keys) #dict_keys(['张三', '李四', '王五'])
print(type(keys)) #<class 'dict_keys'>
print(list(keys)) #将所有的key组成的视图转换为列表 ['张三', '李四', '王五']
# 获取所有的值value
values=scores.values()
print(values) #dict_values([100, 98, 45])
print(type(values)) #<class 'dict_values'>
print(list(values)) #将所有的vlaue组成的视图转换为列表 [100, 98, 45]
# 获取所有的key-value对
items=scores.items()
print(items) #dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
print(type(items)) #<class 'dict_items'>
print(list(items)) #将所有的key-value组成的视图转换为列表 [('张三', 100), ('李四', 98), ('王五', 45)]
(5)字典的遍历
# 字典的遍历
scores={'张三':100,'李四':98,'王五':45}
for item in scores :
print(item,scores[item],scores.get(item)) #value key key
(6)字典的特点
①字典的key不允许重复,一旦出现会造成覆盖现象,value可以重复
②字典中的所有元素都是无序的
③字典中的key是不可变对象
④字典可以根据需要动态伸缩
⑤字典是以空间换时间,会造成较多的空间
3.2 元组
1、Python内置的不可变序列的数据结构之一
可变序列:列表,字典,可以进行增、删、改、查操作,且前后地址不变。
不可变序列:字符串,元组,没有增、删、改、查操作。
2、元组的创建
# 元组的创建方式
#方法一:
t=('Python','world',98)
print(t)
print(type(t))
t2='Python','world',98 #方法一省略了小括号
print(t2)
print(type(t2))
#若元组中只包含一个元素,则必须包含逗号和括号
t3=('Python',)
print(t3)
print(type(t3))
#方法二:内置函数tuple()
t1=tuple(('Python','world',98))
print(t1)
print(type(t1))
# 空元组的创建方式
t4=()
t5=tuple()
3、元组的遍历
# 元组的遍历
t=('Python','world',98)
for item in t :
print(item)
DAY4:
4.1 集合
1、集合的创建
# 集合的创建方式
#方法一:
s={2,3,4,5,6,7,7} #集合中的元素不允许重复
print(s) #{2, 3, 4, 5, 6, 7}
#方法二:set()
s1=set(range(6))
print(s1,type(s1)) #{0, 1, 2, 3, 4, 5} <class 'set'>
s2=set(['Python','hello',90])
print(s2,type(s2)) #{'hello', 'Python', 90} <class 'set'>
s3=set(('Python','hello',90))
print(s3,type(s3)) #{'hello', 'Python', 90} <class 'set'>
s4=set('Python')
print(s4,type(s4)) #{'h', 'y', 't', 'n', 'P', 'o'} <class 'set'>
s5=set({'Python','hello',90})
print(s5,type(s5)) #{'hello', 'Python', 90} <class 'set'>
#空集合
s6=set() #直接用s={} 类型为花括号
print(s6,type(s6)) #set() <class 'set'>
# 集合生成式
s7={ i*i for i in range(6)}
print(s7) #{0, 1, 4, 9, 16, 25}
2、集合的相关操作
(1)集合元素的判断
In或者not in
(2)集合元素的新增
调用add()方法,一次只添加一个元素
调用update()方法至少添加一个元素
(3)集合元素的删除
调用remove(),一次删除一个指定元素,若不存在抛出KeyError
调用discard(),一次删除一个指定元素,若不存在不抛出异常
调用pop(),一个只删除一个任意元素,不能指定参数
调用clear(),清空集合
3、集合间的关系
# 集合之间的关系
# 是否相等
s1={10,20,30,40}
s2={10,20,30,40,50}
s3={10,20,90}
s4={50,60,70}
print(s1==s2) #False
print(s1!=s2) #True
#一个集合是否是另一个集合的子集
print(s1.issubset(s2)) #True
#一个集合是否是另外一个集合的超集
print(s2.issuperset(s1)) #True
#两个集合是否有交集
print(s1.isdisjoint(s2)) #False 有交集为False
print(s1.isdisjoint(s3)) #False
print(s1.isdisjoint(s4)) #True 没有交集为True
4、集合的数据操作
# 集合的数据操作
#两个集合的交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2)) #{40, 20, 30}
print(s1 & s2) #{40, 20, 30}
#两个集合的并集
print(s1.union(s2)) #{40, 10, 50, 20, 60, 30}
print(s1 | s2) #{40, 10, 50, 20, 60, 30}
#两个集合的差集
print(s1.difference(s2)) #{10}
print(s1 - s2) #{10}
#两个集合的对称差集
print(s1.symmetric_difference(s2)) #{50, 10, 60}
print(s1 ^ s2) #{50, 10, 60}
4.2 字符串
1、字符串的查询操作
(1)index():查找子串第一次出现的位置,不存在抛出异常ValueError
(2)rindex():查找子串最后一次出现的位置,不存在抛出异常ValueError
(3)find():查找子串第一次出现的位置,不存在返回-1
(4)rfind():查找子串最后一次出现的位置,不存在返回-1
2、字符串的大小写转换操作
(1)upper():把字符串中所有字符都转成大写字母
(2)lower():把字符串中所有字符都转成小写字母
(3)swapcase():把字符串中所有大写字母转成小写字母,把所有小写字母转换为大写字母
(4)capitalize():把第一个字符转换为大写,把其余字符转换为小写
(5)title():把每个单词第一个字符转换为大写,把每个单词的剩余字符转换为小写
3、字符串对齐操作
# 字符串内容对齐操作
s='hello,Python'
#居中对齐,第一个参数指定宽度,第二个参数指定填充字符,第二个字符是可选的,默认是空格,若设置宽度小于实际宽度则返回原字符串
print(s.center(20,'*')) #****hello,Python****
#左对齐,第一个参数指定宽度,第二个参数指定填充字符,第二个字符是可选的,默认是空格,若设置宽度小于实际宽度则返回原字符串
print(s.ljust(20,'*')) #hello,Python********
print(s.ljust(10,'*')) #hello,Python
#右对齐,第一个参数指定宽度,第二个参数指定填充字符,第二个字符是可选的,默认是空格,若设置宽度小于实际宽度则返回原字符串
print(s.rjust(20,'*')) #********hello,Python
print(s.rjust(20)) # hello,Python
#右对齐,左边用0填充,只有一个参数指定宽度,若设置宽度小于实际宽度则返回原字符串
print(s.zfill(20)) #00000000hello,Python
4、字符串的劈分
# 字符串的劈分
# split 从左边开始劈分,默认劈分字符是空格字符串,返回值是一个列表,通过sep指定劈分字符,maxsplit指定最大劈分次数
s='hello world python'
print(s.split()) #['hello', 'world', 'python']
s1='hello|world|python'
print(s1.split(sep='|')) #['hello', 'world', 'python']
print(s1.split(sep='|',maxsplit=1)) #['hello', 'world|python']
# rsplit 从右边开始劈分,默认劈分字符是空格字符串,返回值是一个列表,通过sep指定劈分字符,maxsplit指定最大劈分次数
s='hello world python'
print(s.rsplit()) #['hello', 'world', 'python']
s1='hello|world|python'
print(s1.rsplit(sep='|')) #['hello', 'world', 'python']
print(s1.rsplit(sep='|',maxsplit=1)) #['hello|world', 'python']
5、判断字符串操作
#isidentifier():判断指定的字符串是不是合法的标识符
#isspace():判断指定的字符串是否全部由空白字符组成(回车、换行、水平制表符)
#isalpha():判断指定的字符串是否全部由字母组成
#isdecimal():判断指定的字符串是否全部由十进制的数字组成
#isnumeric():判断指定的字符串是否全部由数字组成
#isalnum():判断指定字符串是否全部由字母和数字组成
6、字符串的替换和合并
# 字符串的替换和合并
# replace:替换,第一个参数指定被替换的子串,第二个参数指定替换子串的字符串,,第三个参数指定最大替换次数
s='hello,Python'
print(s.replace('Python','Java')) #hello,Java
s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',2)) #hello,Java,Java,Python
# join:合并,将列表或元组只的字符串合并成一个字符串
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(t)) #helloJavaPython
print('*'.join('Python')) #P*y*t*h*o*n
7、字符串的比较操作
运算符:>,>=,<,<=,==,!=
8、字符串的切片操作
# 字符串的切片操作
#切片[start:end:step]
s='hello,Python'
s1=s[:5]
s2=s[6:]
s3='!'
newstr=s1+s3+s2
print(s1) #hello
print(s2) #Python
print(newstr) #hello!Python
9、格式化字符串
#(1) %占位符 类似C语言
name='张三'
age=20
print('我叫%s,今年%d岁' % (name,age)) #我叫张三,今年20岁
print('%10d' % age) # 20 占10位
#(2) {}
print('我叫{0},今年{1}岁'.format(name,age)) #我叫张三,今年20岁
print('{0:.3}'.format(3.1415926)) #3.14
print('{0:.3f}'.format(3.1415926)) #3.142
print('{0:10.3f}'.format(3.1415926)) #一共是10位,三位小数
#(3)f-string
print(f'我叫{name},今年{age}岁') #我叫张三,今年20岁
10、字符串的编码与解码
# 字符串的编码与解码
s='天涯共此时'
#编码
print(s.encode(encoding='GBK')) #在GBK这种编码格式中,一个中文占两个字节 b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
print(s.encode(encoding='UTF-8')) #在UTF-8这种编码格式中,一个中文占三个字节 b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'
#解码
byte=s.encode(encoding='GBK')
print(byte.decode(encoding='GBK')) #天涯共此时
DAY5:
5.1 函数
1.函数的创建与调用
# 函数的定义与调用
def calc(a,b) :
c=a+b
return c
result=calc(10,20)
print(result)
# 函数返回值为多个时,返回数据类型为元组
2.个数可变的位置参数与个数可变的关键字形参
# 个数可变的位置形参 输出形式为元组形式 只能是一个
def fun(*args):
print(args)
fun(10) #(10,)
fun(10,30) #(10, 30)
fun(30,405,50) #(30, 405, 50)
# 个数可变的关键字形参 输出形式为字典形式 只能是一个
def fun1(**args):
print(args)
fun1(a=10) #{'a': 10}
fun1(a=10,b=30) #{'a': 10, 'b': 30}
# 在一个函数的定义过程中,既有个数可变的关键字形参,又有个数可变的位置形参
# 要求:个数可变的位置形参需要放在个数可变的关键字形参之前
def fun2(*arg1,**arg2):
pass
# 需求:c,d只能采用关键字实参传递
def fun3(a,b,*,c,d):
pass
3、实参用法
# 调用参数用法
def fun(a,b,c):
print('a=',a,'b=',b,'c=',c)
# 在函数调用时的参数传递,称为位置传参
fun(10,20,30) #a= 10 b= 20 c= 30
# 在函数调用时,将列表中的每个元素都转换为位置实参传入
lst=[11,22,33]
fun(*lst) #a= 11 b= 22 c= 33
# 函数的调用,所以是关键字实参
fun(a=100,b=200,c=300) #a= 100 b= 200 c= 300
# 在函数调用时,将字典中的键值对都转换成关键字实参传入
dic={'a':111,'b':222,'c':333}
fun(**dic) #a= 111 b= 222 c= 333
4、函数内部定义的变量为局部变量,如果在局部变量前使用global声明,这个变量实际上就变成了全局变量