文章目录
目录
(3)多分支 if ... else if ... else 结构
(1)range(stop) 创建一个(0,stop)之间的整数序列,步长为1
(2)给了两个数,range(start,stop),创建一个(start,stop)之间的整数序列,步长为1
(3)给了三个参数,range(start,stop,step),创建一个(start,stop,step)之间的整数序列,步长为step
前言
提示:以下是本篇文章正文内容,下面案例可供参考
一、Python基础
1,输出函数print()
print()函数输出的内容可以是数字
print()函数输出的内容可以是数字符串
print()函数输出的内容可以是含有运算符的表达式
print()函数还可以将内容输出的目的地
(1)显示器
(2)文件
print()函数的输出格式
(1)换行
(2)不换行
#可以输出字符串 print("HEllo eorld") #含有运算符的表达式 print(3+1) #数据输出文件中 注意点1,所指定的盘符要存在,2要使用file=fp fp=open('E:/text.text','a+') #如果文件不存在就去创建,如果存在就继续追加 print('hellow world',file=fp) fp.close() #不进行换行输出 print('hello world','Python',"你好")
2,转义字符
就是反斜杠+想要实现的转义功能首字母
print(('hellooooo\tworld')) print(('hello\rworld')) #r表示回车 从头开始 print(('hello\bworld')) #b 表示退一个格 没有o了 \t 是每个输出值空一格 print('http:\\www.baidu.com') #进行输出的时候遇见两个\最终会以一个\显示 print('http:\\\\www.baidu.com') print('老师说:‘大家好\'') #想在输出的结果中出现单引号,那就输出一个反斜线就行 这就是转义字符 #不希望字符串中的转义字符起作用,就使用原字符,就是在字符串之前加上r或R print(r'hello\nworld') #\n就不起作用了 #注意事项,最后一个字符不能是\,两个可以
hellow
world
hello world
hellooooo world
world
hellworld
http:\www.baidu.com
http:\\www.baidu.com
老师说:‘大家好'
hello\nworld
3,二进制与字符编码
8个位子是一个字节byte
1024byte=1KB
8个位置可以表示256种状态
也就ASCII表共有256种状态
4,Python当中的标识符与保留字
Pyton的规矩
保留字有些单词我们是不能用的
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', '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']
Process finished with exit code 0
自己命名的就为标识符:
不能以数字开头,
不能是我们的保留字
严格区分大小写
5,Python中的变量与数据类型
name='航空' print(name) print('标识',id(name)) #存储的内存地址 print('类型',type(name)) print('值',name)
航空
标识 2351847402032
类型 <class 'str'>
值 航空
数据类型:
整数类型:int 89
浮点类型:float 89.9999
布尔类型:bool True/False
字符串类型:str 航空 只要加上单引号,双引号都是字符串类型
单引号和双引号只能在一行书写,二三引号或多引号能在多行书写
Python默认的位是十进制
6,数据类型转换
#将int类型通过str类型转换位字符串类型 #str()是将其他类型转化位str类型的 #int()将其他类型转化为int类型 #将str类型转化为int类型,字符串要为数字串 #将float转化为int类型,截取整体部分 #将str转化为int类型,报错,因为字符串为小数串 #将str类型转化为为int类型时必须是数字串,并且还要为整数,非数字串也是不能转的
#float()将其他类型转化为float类型 #如果字符串是非数字串是不能转换 s1='126.1' s2=23 s3='24' ff=True print(float(s1),type(float(s1))) print(float(s2),type(float(s2))) print(float(s3),type(float(s3))) print(float(ff),type(float(ff)))
126.1 <class 'float'>
23.0 <class 'float'>
24.0 <class 'float'>
1.0 <class 'float'>
7,Python中的注释
中文编码声明注释
#coding:utf-8 写在文档最前面的,标记你的文件的存储格式
8,输出
#input()函数的使用 //input函数结果是一个str类型的
present=input('你想要什么?')
print(present,type(present))
你想要什么?想要吃饭
想要吃饭 <class 'str'>
#要求从键盘输入两个整数,计算两个整数的和 a=input('请输入一个数') b=input('请输入另一个数') print(a+b)
请输入一个数12
请输入另一个数10
1210 12和10都是str类型,因此这时候的加号是一个连接作用
9,Python中的运算符
(1)标准运算符(+,-,*,/,//(整除)
print(11/2) #除法运算 print(11//2) #整除运算
5.5
5
#向下取整要取-3 一正一负
#都向下取整
print(9//-4) -3
print(-9//4) -3
(2)取余运算符(%)
print(11%2) #取余运算
1
(3)幂运算符(**)
#向下取整要取-3 一正一负 print(9//-4) #都向下取整 print(-9//4) #余数=被除数-除数*商 print(9%-4) #9-(-4)*(-3)--》9-12=-3 print(-9%4) #-9-4*(-3)--》-9+12=3
链式赋值
还支持解包赋值
a,b,c=20,30,40
print(a,b,c)
20 30 40
#交换 方便交换两个数,不用中间变量
a,b=b,a
print(a,b)
30 20
(4)比较运算符
#比较运算符的结果是布尔类型
a,b=20,30
print('a>b吗?',a>b)
print('a<b吗?',a<b)
print('a>=b吗?',a>=b)
print('a<=b吗?',a<=b)
print('a==b吗?',a==b)
'''
一个‘=’是赋值运算符。==为比较运算符,
一个变量是由变量,标识,值来组成,==是比较的值
比较对象的标识是is
'''
a=10
b=10
#a和b的值和标识都是相等的 ,其中标识就是地址
print(a==b) #比较值
print(a is b) #比较地址
lst1=[11,22,33,44] list2=[11,22,33,44] print(lst1==list2) print(lst1 is list2) 值一样,但是地址不一样 print(lst1 is not list2) True False
(5)布尔运算符
逻辑关系
且 and
一个错全错
全队才对
a,b=1,2 print(a==1 and b==2) true print(a==1 and b<2) false
或 or
一个对就对
全错才错
print(a==1 or b<2) true print(a!=1 or b==2) true
取反 not
对bool类型整体取反
f=True f2=False print(not f) false print(not f2) true
in与not in
s='hellow world' print('w'in s) print('k'in s) print('w'not in s) print('k'not in s)
(7)位运算符
将数据转换成二进制进行计算
位与&
对应数位都是1结果位数才为1,否者为0
位或|
对应数位都是0结果才为0,否则位1
左移运算符 <<
每移动一位乘以2
右移运算符 >>
向右移动一位相当于除以2
print(4>>2) 向右移动两位 结果为1
(8)运算符的优先级
先算算术运算符,再算位运算,然后在比较运算,最后为布尔运算
二、流程控制
任何简单或者复杂的算法都可以由顺序结构,选择结构和嵌套结构这三个基本结构组合而成
1,程序的组织结构
2,顺序结构
3,对象的布尔值
对象的布尔值,Python一切皆对象,所有的对象都有一个布尔值
一下对象的布尔值都为False,可以用bool()函数来判断
None
空字符列表
空列表
空元组
空字典
空集合
print(bool(0)) print(bool(0.0)) print(bool(None)) print(bool('')) print(bool("")) print(bool([])) #空列表 print(bool(list())) #空列表 print(bool(())) #空元组 print(bool(tuple())) #空字元组 print(bool({})) #空字典 print(bool(dict()))#空字典 print(bool(set()))#空集合
以上对象全为False
4,分支结构
(1)单分支if结构
money=1000 #金额 s=int(input('请输入取款金额:')) #取款金额 if money>=s: money=money-s print('取款成功,余额为:',money)
(2)双分支if..else结构
if 条件表达式:
条件执行体1
else
条件执行体2
num=int(input('输入一个整数:')) if num%2==0: print('是偶数') else: print('是奇数')
(3)多分支 if ... else if ... else 结构
if 条件表达式1:
条件执行语句1
elif 条件表达式2:
条件执行语句2
elif条件表达式3:
条件执行语句3
【else:】可写可不写
#多分支结构 num=int(input('请输入一个分数'))
if 90<=num<=100:
还可以直接这样使用
if num>=90 and num<=100: print('A级') elif num>=80 and num<=89: print('B级') elif num>=70 and num<=79: print('C级') elif num>=60 and num<=69: print("D级") else: print('数据出错')
(4)if语句的嵌套
if条件表达式1:
if内层条件表达试:
内层条件执行体1
else:
内层条件执行体2
else:
条件执行体
例子:
# 嵌套if ''' 会员是>=200 8折 会员是>=100 9折 非会员 >=200 9.5折 不打折 ''' money=float(input('请输入购物总额:')) answer=input('您是会员吗?') if answer=='y': print('您是会员!') if money >= 200: print('会员打八折', money * 0.8) elif money >= 100: print('会员打9折', money * 0.9) else: print('会员不够打折优惠') else: print('您不是会员') if money>=200: print('非会员打9.5折',money*0.95) else: print('非会员不够打折优惠',money)
(5)条件语句
#条件语句 num_a=int(input('请输入一个数字')) num_b=int(input('请输入另一个数字')) print('使用条件表达式进行比较') print((num_a,'大于等于',num_b) if num_a>=num_b else (num_a,'小于等于',num_b))
if前面的为true else 后面的为false
还可以使用+进行连接,但是在连接之前必须都要转化为str类型的
print(str(num_a)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于等于'+str(num_b))
5,pass空语句
语句什么都不做,只是一个占位符,用在语法需要语句的地方
什么时候使用:先搭建语法结构,但是还没想好代码怎么写的时候
那些语句一起使用:
if语句
#pass语句 answer=input('您是会员吗?') if answer=='y': # 这个时候你还没想到是会员的时候代码怎么写就可以使用pass pass else: # 这个时候你还没想到是非会员的时候代码怎么写就可以使用pass pass
if answer:
可以直接把表达式值当作条件去判断
6,循环语句
1,range()函数的使用
用于生成一个整数序列
创建range()的三个方式
(1)range(stop) 创建一个(0,stop)之间的整数序列,步长为1
#第一种创建方式,只有一个参数,小括号中就只有一个数 r=range(10) #默认从0开始,默认相差为1 print(r) #range(0,9) print(list(r)) #用于查看range对象中的整数序列 ,list是一个列表
range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
(2)给了两个数,range(start,stop),创建一个(start,stop)之间的整数序列,步长为1
# 第二种创建方式,给了两个数, r=range(1,10) # 指定了起始值,从1开始到10结束,默认步长为1 print(list(r)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
(3)给了三个参数,range(start,stop,step),创建一个(start,stop,step)之间的整数序列,步长为step
# 第三种创建方式,给了三个数, r=range(1,10,2) # 指定了起始值,从1开始到10结束,默认步长为step 2 print(list(r))
[1, 3, 5, 7, 9]
2,in 与not in来判断整序列中是否存在指定的整数
'''判断指定的整数在序列中是否存在in,not in''' print(10 in r) print(9 in r) print(9 not in r)
False
True
False
range()返回值是一个迭代器对象,range()优点是range对象所占用的空间都是相同的,因为仅仅需要存储,start,stop,step三个值,只有当用到range对象时候,才会计算序列中的相关元素,如果不用他是不计算的
3,while循环
while 条件表达式:
条件执行语句(循环体)
while a<10: print(a) a=a+1
if 是判断一次条件,而while是判断多次
a=0 sum=0 while a<5: sum=sum+a a=a+1 print('和为:',sum)
其中print('和为:',sum)要靠最左,不然会进入whil而进行循环
if not bool(num%2):与if num%2==0:是一样的操作
4,for-in循环
遍历问题
语法结构:
for 自定义的变量 in 可迭代对象:
循环体
for item in 'Python': print(item)
一次从Python中取出字母赋值给item,并输出,第一次取p,第二次取y
也就是Python是可迭代对象
列1;for item in range(10): print(item)
列2:#如果在循环体中不需要使用自定义变量,可将自定义变量写为‘_' for _ in range(5): print('生而为人我很抱歉')
输出5次
生而为人我很抱歉
生而为人我很抱歉
生而为人我很抱歉
生而为人我很抱歉
生而为人我很抱歉
列3:sum=0 for item in range(1,101): if not bool(item%2): sum=sum+item print('偶数和为:',sum)
5,break,continue,else语句
break 用于结束循环结构,通常与分支结构if共同使用
列1:
''' 如果从键盘输入密码,最多三次,正确后就结束循环 ''' for item in range(3): 也可以使用这样代码: while a<3: pwd=input('你的密码:') #始终牢记input是字符串 if pwd=='8888': break else: print('密码不正确')
continue语句用于结束当前循环,进入下一次循环,通常与分支结构if一起使用
不一样的是break是直接结束循环,而contiue是结束本次循环,进入下一次循环
列题:''' 要求输出1到50之间的所有5的倍数 ,只要余数为0或者5的都是5的倍数 ''' for item in range(1,51): if item%5==0: print(item) print('------使用continue-----') for item in range(1,51): if item%5!=0: continue print(item)
6,嵌套循环
例子:打印3行四列的矩形
'''输出一个三行四列的矩形''' for i in range(1,4): # 行表,执行三次,一次是一行 for j in range(1,5): print('*',end='\t') # 不含行输出 print()
例子:打印九九乘法表
#输出九九乘法表 for i in range(1,10): for j in range(1,i+1): print(i,'*',j,'=',i*j,end='\t') print()
二重循环中的break和continue
只用于内层的循环
'''流程控制豫剧break与continue在二重循环中的使用''' for i in range(5): for j in range(1,11): if j%2==0: # break continue print(j,end='\t') print()
1 3 5 7 9
1 3 5 7 9
1 3 5 7 9
1 3 5 7 9
1 3 5 7 9
三、数据序列
字符串
1,字符串的驻留机制
字符串是一个基本数据类型,是不可变的字符序列
'''字符串可以用单引号,双引号也可以使用多引号来定义''' a='Python' b="python" c='''Python''' #以上地址都是一样的
2,字符串的常用操作
'''字符串中大小写转换的方法''' s='hello python' a=s.upper() #将其转换为大写,upper转换为大写之后会产生一个新的字符对象 b=s.lower() #将其转换为小写,lower也是转换之后会产生一个新的字符对象 print(b==s) #内容是相等的 print(b is s) #会报错,因为内容是相等的但是地址却不同 c=s.swapcase() #是将s中大写的变成小写,小写的变成大写 d=s.title() #将每个英文单词的第一个字母转换为大写,把剩余的单词都转换为小写
#字符串1的查询操作''' s='hello,hello' print(s.index('lo')) #3 print(s.find('lo')) #3 print(s.rindex('lo')) #9 print(s.rfind('lo')) #9
rindex和rfind都是逆向进行索引,并且,index在查询没有的时候会抛异常,而find或rfind在查询中没有的时候不会抛异常,而会输出-1
s='hello python' print(s.center((20,'*')) ) #就是一共占用20个位置,该字符在中间,其中的两边用*来填充
****hello python****
print(s.ljust(20,'*') ) #左对齐
hello python********
print(s.rjust(20,'*')) #右对齐,默认是空格 print(s.zfill(20)) #左对齐,只允许设置宽度剩余的全用来0来填充 print('-1908'.zfill(8)) #其中左对齐后,0的填充在负号的后面
lst=s.split() #没有指定分隔符的时候,就会按照空格去区分 print(lst) s1='hello|world|python' print(s1.split(sep='|')) #指定分隔符是’|‘ print(s1.split(sep='|',maxsplit=1)) #也就是自定义’|‘为分隔符,并且指定只分割’|‘前的一块,后面的放在一起 '''rsplit从右侧开始劈分''' print(s1.rsplit()) #没有指定分隔符依旧使用空格进行区分 print(s1.rsplit('|')) #默认分隔符为‘|’ print(s1.rsplit(sep='|',maxsplit=1)) #就是默认用‘|’分割,并且只分割一个,从右边开始,其他的放在一起
print(s.isidentifier()) print('heool'.isidentifier()) '''判断是否是空白字符,isspace''' print('\t'.isspace()) print(' '.isspace()) '''判断是否全部由字母组成''' print('qbc'.isalpha()) print('张三'.isalpha()) #汉字也是由字母组成 '''判断是否由十进制的数字组成''' print('919'.isdecimal()) print('123四'.isdecimal())#不是全部由十进制组成 '''是否全部由数字组成''' print('1234'.isnumeric()) print('123四'.isnumeric()) #罗马数字,大写数学都是数字 '''是否全部由字母和数字组成''' print('ABD11'.isalnum()) print('张三12'.isalnum())#汉字也是字母,!不是字母和数字
s='hello Python' print(s.replace('Python','java')) #用java替换掉了s中的Python s1='hello,Python,Python,Python' print(s1.replace('Python','java',2))#用java换Python换两次就够了,尽管有三个Python lst=['hello','java','python'] #列表当中有三个字符串 print('|'.join(lst)) #用’|‘将列表中的三个字符串进行连接 print(' '.join(lst)) #用空格进行连接 t=('hello','java','python') print(' '.join(t)) #将元组进行连接 print('*'.join('Python')) #将Python看作字符串序列进行连接
hello java
hello,java,java,Python
hello|java|python
hello java python
hello java python
P*y*t*h*o*n
3,字符串的比较
print('apply'>'app') print('apply'>'banan') print(ord('a'),ord('b')) #Ascii码的相互转换 ord chr print(chr(98),chr(97)) '''==与is区别 == 比较的是 value is 比较的是地址值id ''' a=b='Python' c='Python' #a,b,c的地址都是一样的,因为字符串具有驻留机制
4,字符串的切片操作
'''字符串是不可变类型,不能进行增删改的操作,切片之后都将会产生一个新的对象''' s='hello,Python' print('------切片[start:end:step') print(s[::2])#默认从0开始,没有写结束,默认到字符串的最后一个元素结束 print(s[::-1])#默认从字符串的最后一个元素开始,到字符串的第一个元素结束,因为步长为负数,-1最后一个元素 s1=s[:5]#不写起始位置,将会从0开始,默认步长为1 s2=s[6:]#不写终点位置,一般会切到最后 s3='!' newstr=s1+s3+s2 print(s1) print(s2) print(newstr) print('------------') print(id(s1)) print(id(s2)) print(id(s3)) print(id(newstr)) #切片的地址都是不一样的
5,格式化字符串
'''%占位符''' name='张三' age=20 print('我是%s,今年%d岁'%(name,age))
我是张三,今年20岁
'''%占位符'''
name='张三'
age=20
print('我是%s,今年%d岁'%(name,age))
'''{}占位符'''
print('我叫{0},今年{1}岁'.format(name,age))
'''f-string'''
print(f'我叫{name},今年{age}岁') #只需前面加上f
'''精度'''
print('%10d'%99) #%10d指的是宽度
print('%.3f' % 3.1415926) #%.3f指的是保留三位小数
print('%10.3f'%3.1415926) #%10.3f表示的是,10是占位总宽度为10,.3是保留多少小数
print('{0:.3}'.format(3.1415926)) #.3表示的是一共3位数。.3f表示的是3位小数
print('{0:10.3f}'.format(3.1415926))#其中{}中的0也是可以略的,同时设置宽度和精度
6,字符串的编码转换
s='天涯共此时' '''编码''' print(s.encode(encoding='GBK')) #在GBK这种编码格式中,一个中文占两个字节 print(s.encode(encoding='UTF-8'))#在UTF-8这种编码格式中,一个中文占三个字节 '''解码''' #byte代表的就是一个二进制数据(字节类型的数据) byte=s.encode(encoding='GBK') #编码 print(byte.decode(encoding='GBK')) #解码 编码和解码要一样 否则不能解码
7,字符串总结
字典
1,什么是字典
字典是Python内置的数据结构之一,与列表一样是一个可变序列(可以增删改操作),以键值对的方式存储数据,字典是一个无序的序列。用{ }来定义,字典是一对对来存储的“
”:“之前的叫做键,‘:’之后的叫做值,存储在字典中要通过hash(key)函数来进行的,所以是无序的,因此键的不可变序列,字符串也是不可变序列
2,字典的原理
3,字典的创建与删除
# 最常用的方式:使用使用花括号 score={'张三':100,'李四':89,'王五':20} print(score) print(type(score))
{'张三': 100, '李四': 89, '王五': 20}
<class 'dict'>
# 使用内置的函数dict() 左边是键右边是值 student=dict(name='jack',age=20) print(student)
{'name': 'jack', 'age': 20}
'''可以创建空字典''' d={} print(d)
字典中元素的获取
'''第一种获取字典元素的方式 使用【】''' print(score['张三']) #如果查找的键不存在会报错,而get()不会报错 '''使用get()方法''' print(score.get('张三')) print(score.get('麻七'),200) #200是早查找’麻七‘不存在对应值的一个默认值
key的判断in not in
score={'张三':100,'李四':89,'王五':20} print('张三'in score) print('张三'not in score)
True
False
字典的删除 del scores【'张三’】
del score['张三'] print(score)
删除一对
字典元素的新增 scor【‘JACK’】=90
score.clear() #情况字典的所有元素 score['陈六']=80 #添加键值对 score['陈六']=100 #修改键值对
4,字典的查询操作
获取字典的视图操作三个方法
key()获取字典中所有的key
value()获取字典的所有值
items()获取字典中所有的key,value对
#获取所有的键 score={'张三':100,'李四':89,'王五':20} keys=score.keys() print(keys) print(type(keys)) print(list(keys)) #将所有键组成的视图转化为列表 # 获取所有的值 values=score.values() print(values) print(type(values)) print(list(values)) #将所有值组成的视图转化为列表 # 获取所有的键值对 items=score.items() print(items) #元组 print(type(items)) print(list(items)) #将所有键值对组成的视图转化为列表,转换之后的列表是由元组组成的
5,字典元素的增,删,改操作
key的判断in not in
score={'张三':100,'李四':89,'王五':20} print('张三'in score) print('张三'not in score)
True
False
字典的删除 del scores【'张三’】
del score['张三'] print(score)
删除一对
字典元素的新增 scor【‘JACK’】=90
score.clear() #情况字典的所有元素 score['陈六']=80 #添加键值对 score['陈六']=100 #修改键值对
字典元素的遍历
for item in scores:
print(item)
获取的实际上是字典当中的键
score={'张三':100,'李四':89,'王五':20} for item in score: print(item,score[item],score.get(item)) #前一个是键,后两个获取的是键对应的值
张三 100 100
李四 89 89
王五 20 20
6,字典的推导式
字典的一些特点:
字典中的所有元素都是一个Key-value对,key不允许重复,value可以重复
字典中的元素是无序的
字典的key必须是不可变对象
字典也可以根据需要动态的伸缩
字典会浪费较大的内村,是一种使用空间换时间的数据结构
列表
变量只能存储一个元素,而列表是以一个大容器,可以存储N多个元素,程序可以方便的对这些数据进行整体操作,相当于其他语言的数组。
a=10 # 变量存储的是一个对象的引用 lst=['hello','world','98'] print(id(lst)) print(type(lst)) print(lst)
1967148470336
<class 'list'>
['hello', 'world', '98']
1,列表的创建与删除
'''创建列表的第一种方式'''
lst=['hello','world','98']
'''创建列表的第二次方式'''
lst2=list(['hello','world','98'])
列表的特点:
列表映射一个列表的数据
列表里面可以重复数据
任意数据类型可以混合
根据需要动态分配和回收内村
2,列表的查询操作
lst=['hello','world','98','hello'] print(lst.index('hello'))
0
如果列表有相同元素,只返回列表中第一个元素的索引
指定范围内查找索引
# print(lst.index('hello',1,3)) #意思是在列表中从索引为1的元素到索引为3的元素进行查找hello,不包括索引为3的 print(lst.index('hello',1,4)) #意思是在列表中从索引为1的元素到索引为3的元素进行查找hello
获取列表当中的单个元素
# 希望获取索引为2的元素 print(lst[2]) #获取索引为-3的元素 print(lst[-3]) #从后往前数 范围为-N到-1 #获取索引为10的位置 print([lst[10]]) # 超出范围会报错
str = "abcdefa"
print(str.find("a")) # 从下标0开始,查找在字符串里第一个出现的子串,返回结果
print(str.find("a",1)) # 从下标1开始,查找在字符串里第一个出现的子串:返回结果6
print(str.find("7"))# 查找不到返回-1
获取列表当中的多个元素
列表名[start:stop:step]
#开始为1,步长为6,每步为1 print(lst[1:6:1]) #不包含索引为6 print('原列表',id(lst)) lst2=lst[1:6:1] print('切的片段:',id(lst2)) print(lst[1:6]) # 默认步长为1 print(lst[1:6:]) # 也是默认步长为1 print(lst[1:6:2]) print(lst[:6:2]) #默认从0开始 print(lst[1::2]) #长度默认为结束
print('-----步长为负数的情况-----') print(lst[::-1]) #默认步长为1,且逆序输出 print(lst[7::-1]) #和上输出一样 print(lst[6:0:-1])
print('p' in 'Python') print('k' not in 'Python') # 同样的列表中也可以使用in not in lst=[10,20,'Python','hello'] print(10 not in lst) print(10 in lst) # 也可以遍历列表当中的元素 for item in lst: print(item)
False
True
10
20
Python
hello
3,列表元素的增,删,改操作
列表增加:
'''向列表的末尾添加一个元素''' lst=[10,20,30] lst.append(100) #代表在列表的末尾添加一个元素 print('添加元素之后的列表',lst) #并且标识没有修改 # 在列表的末尾至少添加一个元素 lst2=['hello ','world'] lst.append(lst2) #将列表的元素做为一个元素添加到列表的后面 print(lst) lst.extend(lst2) #是将列表后面扩展了,是将lst2中的每一个元素都当做一个元素添加到末尾多个元素 print(lst) # 在任意位置上添加元素 lst.insert(1,90) #在索引为2的位置上添加元素 print(lst) # 在任意位置上添加n多元素 lst3=['True','false'] lst[1:]=lst3 #切片,没有写结束在哪里,然后把元素切掉后将lst3的元素挨个添加后面
列表删除
lst=[10,20,30,40,50] lst.remove(30) #从列表中移除一个元素,如果重复只移除第一个元素 #pop()根据索引移除元素 lst.pop(1) # 就是将索引为1的元素移除了,如果不指定参数,将删除列表中最后一个元素 print('-----切片-删除至少一个元素,将产生一个新的列表对象') new_list=lst[1:3] #就是说只保留原列表中的第一位到第2位的元素 '''不产生新的列表对象而是删除原列表中的内容''' lst[1:3]=[] #就是用空列表将中间的替代 '''清楚列表中的所有元素''' lst.clear() '''del语句将列表对象删除''' del lst #直接将列表删除
修改列表元素
'''一次修改一个值''' lst[2]=100 #修改固定位置索引上的值
'''一次修改一个值''' lst[2]=100 #修改固定位置索引上的值 ''' 修改列表当中的多个值''' lst[1:3]=[300,400,500]
4,列表元素的排序
sort()方法进行排序
lst=[20,30,12,5,60] print('排序前的列表',lst) #开始排序,调用列表中的sort方法,默认升序排序 lst.sort() print('排序之后的列表',lst) #是在原列表上进行的排序 # 通过指定关键字参数,将列表中的元素进行降序排序 lst.sort(reverse=True) #就是降序排序的判断 lst.sort(reverse=False) #就是降序排序,一般年没有指定就是默认降序· sorted()进行排序 '''使用内置函数进行排序,但是会产生一个新的列表对象''' print('----------使用内置函数sorted()进行排序,将产生一个新的列表对象------') new_lst=sorted(lst) #原列表没有变化,而是产生一个新的列表对象 #指定关键字,来实现降序排序 deec_lst=sorted(reverse=True) #内置函数的降序排序
5,列表的推导式
【i*i for i in range(1,10】
lst=[i for i in range(1,10)] #产生一道九的序列并 print(lst) lst=[i*i for i in range(1,10)] #前面i称为表示列表元素的表达式 print(lst)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 4, 9, 16, 25, 36, 49, 64, 81]
列题: '''列表中的元素的值为2,4,6,8,10''' lst2=[i*2 for i in range(1,6)] print(lst2)
可迭代对象就是指可以进行变量的对象
items=['张三','王五','李四'] prices=[20,30,40] d={item:price for item,price in zip(items,prices) }
元组
1,什么是元组
元组是一个不可变序列,因此没有增删改操作,字符串也是不可变序列
列表,字典是可变序列,因为可以增删改,并且地址也没有发生更改
2,元组的创建方式
t=(‘Python’,‘hello’,90) 外观上和列表相差括号,列表是由方括号表示的【】
''第一种,使用()''' t=('Python','world',98) #其中第一种的创建方式,括号可以不用写,如果一个元组只有一个元素时候要使用,和小括号 t2='Python','world',98 t3=('python',) #一个元素的元组,逗号和括号不能省 '''第二种创建方式,使用内置的函数tuple''' t1=tuple(('typhon','world',90)) # 空元组 t4=() t5=tuple() # 空列表的创建方式 lst=[] lst1=list() #空字典的创建方式 d={} d2=dict()
为什么要将元组设计成不可变序列
在多任务环境下,同时操作对象不需要枷锁
因此,在程序中尽量使用不可变序列
元组中存储的是对象的引用,如果元组中对象是不可变对象,则不能在引用其他对象,如果元组中的对象是可变对象,则可变对象的引用不允许改变,但数据可以改变
t=(10,[20,30],90) print(t) print(type(t)) print(t[0],type(t[0]),id(t[0])) print(t[1],type(t[1]),id(t[1])) #这为列表 print(t[2],type(t[2]),id(t[2])) '''将t0修改为100''' t[0]=100 #错误的,元组是不能修改的,但是由于t[2]为列表,可以修改 t[1].append(100) #这是可以的,并且id是不变的
3,元组的遍历
t=('python','world',98) '''第一种获取元组的方式,使用索引''' print(t[1]) #可能会超出索引 '''遍历元组''' for item in t: print(item) #其中item就是元组的索引长度
4,什么是集合
集合是可变的类型的序列,集合也是{ } 和字典表达方式一样,但是集合不成对出现的,是没有value的字典,也是hash函数进行的
s={ }
5,集合的增删改查操作
集合元素的判断操作
in或not in
集合元素的新增操作
调用daa()方法,一次添中一个元素
调用update()方法,至少添中一个元素
集合元素的删除操作
调用remove()操作,一次删除一个指定元素,如果指定元素不存在就抛出keyerro
调用discard()方法,一次删除一个指定元素,如果指定元素不存在不抛出异常
调用pop()方法,一次删除一个任意元素
调用clear()方法,清空集合
'''集合元素的判断操作''' s={10,20,30,40} print(10 in s) print(100 not in s) #是bool类型 '''集合元素的新增操作''' s.add(90) #添加一个用add print(s) s.update({200,300,400}) #添加一个集合 print(s) s.update([100,20,30]) #update既可以放元组,也可以放列表 s.update((11,1,12)) #update集合添加多个也可以用列表 '''集合元素的删除操作''' s.remove(100) #使用remove删除的时候,不存在的时候会抛出异常 s.discard(500) #使用discard删除的时候,不抛出异常 s.pop() #pop不能添加参数,只能随机删除一个 s.clear() #是清空集合中的元素
6,集合的关系和集合的生成式
两个集合是否相等
可以用==或 !=来判断
一个集合是否是另一个集合的子集
可以调用issubset进行判断
一个集合是否是另一个集合的超集
可以调用issuperset进行判断 超集合也就是这个集合包含另一个集合
两个集合是否没有交集
可以调用方法isdisjoint进行判断
'''两个集合是否相等,元素相同就相等''' s={10,20,30,40} s1={10,20,30} s2={20,30,40,10,50,13} print(s==s2) print(s!=s2) '''一个集合是否是另一个集合的子集''' print(s.issubset(s1)) #s是否是s1的子集 print(s1.issubset(s2)) # '''一个集合是否是另一个集合的超集''' print(s.issuperset(s2)) #正好与子集反过来 '''两个集合是否有交集''' print(s1.isdisjoint(s2)) #若两个子集有交集就是false,没有交集就是true
'''交集操作''' s1={10,20,30,40,50} s2={10,20,30} print(s1.intersection(s2)) print(s1 & s2 ) #intersection 与&是等价的,都是交集操作 '''并集操作''' print(s1.union(s2)) print(s1|s2) #union是和| 等价,并集操作 '''差集操作''' print(s1.difference(s2)) #也就是用s1-s1和s2共同有的部分 print(s1-s2) #- 和上面的difference是一样的都是差集操作 '''对称差集''' print(s1.symmetric_difference(s2)) #就是去掉二者都有的部分,然后将两者剩余的整合在一起 print(s1^s2) #^和symmetric_difference是一样的
集合的生成式
#列表生成式 lst=[i*i for i in range(8)] #大意就是生成0到5之间的整数,然后再将这些整数乘起来(i*i),然后将其放入列表lst当中 print(lst) #集合生成式 lst={i*i for i in range(8)} #其中集合的数据是错乱的 print(lst)
7,列表,字典,元组,集合总结
四、函数
1,函数的创建和调用
def calc(a,b): c=a+b return c result=calc(10,20) print(result)
2,函数的参数传递
def calc(a,b): #a,b是形式参数 c=a+b return c result=calc(10,20) #10,20是实参,实参的位置是函数的调用处 print(result) #关键字实参 res=calc(b=10,a=20) #赋值给名称相同的参数 =号左侧的变量名称就称为关键参数
def fun(arg1,arg2): print('arg1=',arg1) print('arg2=',arg2) arg1=100 arg2.append(100) print('arg1=:',arg1) print('arg2=',arg2) n1=11 n2=[22,33,44] fun(n1,n2) #位置传参,arg1,arg2是函数定义的形参,n1,n2是函数调用的实参,实参和形参名字可以不相同 print('n1=',n1) print('n2=',n2) #其中n1的值是不变的 '''在函数调用的过程中,进行的参数的传递''' '''如果是不可变对象,在函数体内的修改不会影响实参的值 如果是可变对象,在函数体内的修改会影响到实参的值'''
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,30,34,23,44,53,55] print(fun(lst)) '''函数的返回值 (1)如果函数没有返回值【函数执行完毕后,不需要给调用处提供数据] return 可以省略不写 (2)函数的返回值,如果是一个,直接返回类型 (3)函数的返回值,如果是多个,返回值的结果为元组 ''' #(1) def fun1(): print('hello') fun1() #(2) def fun2(): return 'hello' res=fun2() print(res) #(3) 多个返回值返回元组 def fun3(): return 'hello','world' print(fun3())
4,函数的参数定义
'''个数可变的位置参数''' #只能定义一个 def fun(*arges): #*是不知道参数的个数,*是数组,用*定义一个可变的位置形参,结果为一个元组 print(arges) print(arges[0]) fun(10) fun(10,20,30) '''个数可变的关键字形参''' def fun1(**arge): #arge是一个字典 也只能定义一个 print(arge) fun1(a=10) fun1(a=20,b=30,c=40) def fun2(*arges,**arges2): //def fun3(**agre1,*agre): #报错 '''在一个函数的定义之中,既有个数可变的关键字形参,也有个数可变的位置形参,要求,个数可变的位置形参要放在个数可变的关键字形参之前'''
5,变量的作用域
def fun(a,b): c=a+b # c就是局部变量,而a和b是函数的形参,相当于局部变量 print(c) name='刘老师' def fun1(): print(name) fun1() #因为name的全局变量 def fun2(): global age age=20 print(age) fun2() print(age) #函数内部定义的变量,局部变量,但是如果局部变量使用global声明,这个变量实际上就成为了全局变量
6,递归函数
7,函数总结
def fun(a,b,c): lst=[11,12,13] fun(*lst) #不能使用fun(lst) 否则会认为只传了一个参数,只能加个*将列表中的每一个元素都转换为位置实参传入 fun(a=110,b=100,c=200) #函数的调用,所以是关键字实参 dic={'a':111,'b':222,'c':333} fun(**dic) #在函数的调用时,将字典的键值对都转换为关键字实参传入
def fun(*arge): #个数可变的位置形参 print(arge) def fun1(**args): #个数可变的关键字形参 print(args) fun(10,20,30,40) #里面个数想写多少就写多少 fun1(a=10,b=11,c=12) #传多少都可以 def fun4(a,b,*,c,d): #在c和d之前加个*说明c和d只能使用关键字传参,从这个*之后的只能采用关键字实参传递 pass fun4(19,20,c=10,d=10) '''函数定义的形参的训序问题''' def fun5(a,b,*,c,d,**agre): pass def fun6(*args,**arge): pass def fun7(a,b=10,*args,**arge): pass
#斐波那契数列 def fac1(n): if n==1: return 1 elif n==2: return 2 else: return fac1(n-1)+fac1(n-2) #输出这个数列前6位上的数字 for i in range(1,7): print(fac1(i))
lambda表达式
五,Bug的问题
Bug的由来及分类
age=input('请输入你的年龄:') print(type(age)) #问题,通过input输入的是字符串,尽管是数字也是字符串,不能直接那他来进行与数字比较 if age>=18: print('你应该成年了') i=0 while i<10: #一定要给i赋值,并且还要确定不能进入死循环 print(i)
要用==个等号
常见的异常类型
异常处理机制
PyCharm的调用模式
六、文件操作
编码格式介绍
不同的编码方式决定了占用磁盘空间的大小
文件读写原理
先进先出的方式
file=open('a.txt','r') #读完之后赋给file变量 print(file.readlines()) #进行文件的都写操作 #readlines读取后是将其放到一个列表中会读取文件中的所有内容 file.close() #读完进行关闭
file=open('b.txt','w') #进行写操作,若文件没有则进行创建文件 file.write('python') #若文件已经有了,则再写进去会将文件中的内容进行替换 file.close()
文件对象的常用方法
file=open('a.txt','r') print(file.read()) #全部读完 print(file.read(2)) #read(2)代表读取两个字符 print(file.readline()) #readline只读取一行 print(file.readlines()) #读取一行作为列表 file=open('a.txt','a') #a是追加,w是覆盖 file=open('a.txt','w') #不及可以将字符串写进内容,还可以将列表写进去 lst=['java','go','pyhton'] file.writelines(lst) #将列表写进文件中
with语句(上下文管理器)
with open('a.text','r') as file: print(file.read()) 无论是否产都会调用关闭这个函数语句 #此时不必写关闭代码,因为with语句之后就会自动关闭资源了
建议使用with语句来进行读取文件
with open('logo.webp','rb') as scr_file: with open('copy.logo','wb') as target_file: target_file.write(scr_file.read()) #变进行读,变写操作
目录操作
七、面向对象和面向过程
两大编程思想
类和对象的创建
类的创建 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(): print('使用staticmethod进行修饰,所以是静态方法') #类方法 @classmethod def cm(cls): print('类方法,因为使用了classmethod进行修饰') #Python 一切皆对象 Student 是对象吗,内存由开空间吗 print(id(Student)) #1743266496832 print(type(Student)) #<class 'type'> print(Student) #<class '__main__.Student'>
对象的创建
#创建Student类的对象 这个为实例对象,就是给类赋具体值的 stu=Student('张三',20) #创建完对象后,就可以使用类中的所有方法和调用 stu.eat() #还可以以下进行调用和stu.eat() 一样 Student.eat(stu) #都是调用Student中的方法 print(stu.name) print(stu.age)
类对象与类属性
类属性
#类属性的使用方式 print(Student.native_pace) stu1=Student('张三',20) stu2=Student('李四',30) print(stu1.native_pace) print(stu2.native_pace) #结果都为河南 Student.native_pace='天津' print(stu1.native_pace) print(stu2.native_pace) #结果都变为天津了
#类方法是使用方式 Student.cm() #这就是类方法的使用方式
类方法与静态方法
静态方法
#静态方法的使用 Student.method() #静态方法也是直接进行调用
动态绑定属性和方法
动态绑定属性
class Student: def __init__(self,name,age): self.name=name #将局部变量赋给实例变量 self.age=age def eat(self): print(self.name+'在吃饭') stu1=Student('张三',20) stu2=Student('李四',10) #若想给李四单独增加一个属性,让其为性别,这时候就是需要动态的绑定属性了 print('---------为stu2动态绑定一个性别-------') stu2.gender='女' #这就是为stu2单独绑定的性别属性 print(stu1.name,stu1.age) print(stu2.name,stu2.age,stu2.gender)
动态绑定方法
#动态绑定方法 stu2.eat() stu1.eat() def show(): #定义在类之外的称为函数 print('类之外的为函数') stu1.show=show #动态绑定方法 stu1.show()
面向对象
1,封装
提高程序的安全性
class Car: def __init__(self,brand): self.brand=brand def start(self): print('车已启动') 类是对属性和方法的封装 car=Car('奔驰') car.start() print(car.brand)
class Student: def __init__(self,name,age): self.name=name self.__age=age #年龄不希望在类的外部进行使用,因此前面加了两个__ def show(self): print(self.name,self.age) Stu=Student('张三',20) #在类的外部进行使用name和age print(Stu.name) print(Stu.__age) #这个是不能被拿出来 #
2,继承
提高代码的复用性
class Person(object): def __init__(self,name,age): self.name=name self.age=age def info(self): print(self.name,self.age) class Student(Person): def __init__(self,name,age,stu_no): super().__init__(name,age) #super函数是用于调用父类的一个方法 self.stu_no=stu_no class Teach(Person,Student): #里面可以多继承 def __init__(self,name,age,teacheryear): super.__init__(name,age) self.teacheryear=teacheryear stu=Student('李四',20) teacher=Teach('张三',30) stu.info() teacher.info() #info()都是从父类中继承出来的
3,方法重写
4,object类
5,多态
提高程序的可扩展性和可维护性
class Animal(object): def eat(self): print('动物会吃') class Dog(Animal): def eat(self): print('狗吃骨头') class Cat(Animal): def eat(self): print('猫吃鱼') class Person(object): def eat(self): print('人吃五谷杂粮') #定义一个函数 def fun(obj): #obj是传入对象的意思 obj.eat() #开始调用函数 fun(Cat()) #继承类,进行方法重写 fun(Animal()) fun(Dog()) #Person不存在继承关系 fun(Person()) #但是Person有自己的方法所有会调用自己的方法
6,特殊方法和特殊属性
class A: pass class B: pass class C(A,B): def __init__(self,name,age): self.name=name self.age=age class D(A): pass #创建C类的对象 x=C('Jack',20) #x是c类的一个实例对象 print(x.__dict__) #绑定的是实例对象的属性字典 print(C.__dict__) #类属性和方法的字典 print(x.__class__) #输出对象所属的类 print(C.__bases__) #输出的是C类的父类的元素 print(C.__base__) #输出的是和他最近的一个父类 print(C.__mro__) #查看的是一个类的层次结构 print(A.__subclasses__()) #子类的一个列表
class Student: def __init__(self,name): self.name=name def __add__(self, other): return self.name+other.name def __len__(self): #必修要在类中写len方法,才能进行实例的相加 return len(self.name) stu1=Student('张三') stu2=Student('李四') print(stu1+stu2) #由于在类中写了__add__这个方法,所以就可以进行相加了 两个对象相加 lst=[11,22,33,44] print(len(lst)) print(lst.__len__()) #一样的和上面计算列表长度 print(len(stu1))
class CPU: pass class Disk: pass class Computer: def __init__(self,cpu,disk): self.cpu=cpu self.disk=disk #(1)变量的赋值 cpu1=CPU() cpu2=cpu1 print(cpu2,id(cpu1)) print(cpu1,id(cpu2)) #实际上是一个对象放到了两个变量中去 #(2)类的浅拷贝,python一般都是指浅拷贝 print('-----------------') disk=Disk() #创建一个硬盘类的对象 computer=Computer(cpu1,disk) #创建一个计算机类的对象 #开始浅拷贝 import copy computer2=copy.copy(computer) #浅拷贝只拷贝原对象,子对象不拷贝,就是cpu和disk print(computer,computer.cpu,computer.disk) print(computer2,computer2.cpu,computer2.disk)
#深拷贝 computer3=copy.deepcopy(computer) #会将其子对象也进行拷贝 print(computer,computer.cpu,computer.disk) print(computer3,computer3,computer3.cpu,computer3.disk)
八、模块、包、异常
什么是模块
def fun(): #模块包含函数 pass def fun2(): pass class Student: #模块包含类 native_place='吉林' #类中包含类属性 def cat(self,name,age): #类中包含实例方法 self.name=name self.age=age #name。age是实例属性 @classmethod def cm(cls): #类方法 pass @staticmethod #静态方法 def sm(): pass
自定义模块
import math #导入math模块 print(id(math)) print(math.pi) print('--------查看函数有那些可以调用-----') print(dir(math)) #dir查看模块中都有那些方法 from math import pi #这个只是导入了math中的pi print(pi)
以主程序形式执行
def add(a,b): return a+b if __name__=='__main__': #不写这个的时候,否则到时候带调用该模块时候,会执行不该运行的东西 print(add(10,20)) #只有当运行自身模块时候才会进行运算。
Python中的包
包的导入
import papagel.moudel1 as a #a为其别名 #print(papagel.moudel1.a) print(a.a) import 学习包 #在导入含有包的模块时注意事项 import papagel import demo1 #使用import进行导入时只能后面跟包名和模块名 #使用from ....import可以导入包,模块,函数,变量
第三方模块的安装及使用
import sys #导入Python内置的模块 与Python解释器及其环境相关的标准库 print(sys.getsizeof(24)) print(sys.getsizeof(45)) print(sys.getsizeof(True)) import time #导入与时间有关的time print(time.time()) print(time.localtime(time.time())) import urllib.request #导入与爬虫有关的
OS模块应用
import os #os是操作系统上的模块 os.system('notepad.exe') #打开电脑的记事本 os.system('calc.exe') #打开计算器 #还可以直接调用可执行文件 os.startfile('C:\\progaram Files\\Tencent\\QQ\\bin\\qq.exe') #打开可运行的QQ程序
import os #os是操作系统上的模块 print(os.getcwd()) #查询运行的目录路径 #os.listdir('..//chap15') #..//是退一级目录,n把该一级的目录的文件全部输出 #os.mkdir('newdir2') #创建一个目录 os.makedirs('A/B/C') #创建一个多级目录 A里有个B,B里有个C os.rmdir(path) #删除一个目录 os.removedirs(path) #删除多级目录 os.chdir('E:\\path') #将path设置为当前目录
import os.path os.path.abspath(path) #输出绝对路径 绝对路径就是获取路径的全部 os.path.exists(path) #判断目录是否纯在 os.path.join(path2,path1) #路径进行拼接
import os.path os.path.abspath(path) #输出绝对路径 绝对路径就是获取路径的全部 os.path.exists(path) #判断目录是否纯在 os.path.join(path2,path1) #路径进行拼接 os.path.split('path') #分离路径,将目录与文件进行拆分 os.path.splitext('path') #拆分文件与后追名 print(os.path.basename('path')) #提取一个文件的名字
#案例1
#列出指定目录下的所有的py文件 import os path=os.getcwd() #获取当前目录 lst=os.listdir(path) #获取目录所有文件 for filename in lst: if filename.endswith('.py'): #在所有文件的列表中,如果文件是.py结尾的就进行打印输出 print(filename) #进行输出
总结
学生信息管理系统
1,需求分析
2,系统设计
3,系统开发必备
4,主函数设计
5,学生信息维护模块设计
6,查询/统计模块设计
7,排序模块设计
8,项目打包
提示:这里对文章进行总结:
例如:以上就是今天要讲的内容,本文仅仅简单介绍了pandas的使用,而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。