标签：10 语言 Python self lst print hello name

第1章

1. print函数

print(520)
print(13.14)
​
print('Hello World')
print("Hello World")
​
print(3+1)
​
#输出到文件
fp=open('/text.txt', 'a+')  #a+: 如果文件不存在就创建，存在就在文件内容的后面 继续追加内容
print('hello world',file=fp)
fp.close()
​
#不换行输出（输出到一行）
print('hello','world','Python') #， 表示空格

2. 转义字符

print('hello\nworld')
​
print('hello\tworld')
print('helloooo\tworld')
​
print('hello\rworld')#覆盖了hello
​
print('hello\bworld')#\b退一个格，把o 去掉了
​
print('http:\\\\www.baidu.com')
print('老师说:\'大家好\'')
​
#原字符r ，使得 转义字符无效  注意：最后一个字符不能是一个 反斜线（\），要报错，2个可以
print(r'hello\nworld')

第2章

1. 变量

name = '玛丽亚'
print(name)
​
print('标识',id(name))  # name的存储地址
print('类型',type(name))
print('值',name)
​
​
name2 = '张三'
print(name2)
name2 = '李四'
print(name2)

2. 数据类型

#整型int
#可以表示正数，负数，0
n1=90
n2=-11
n3=0
print(n1,type(n1))
print(n2,type(n2))
print(n3,type(n3))
#二进制，十进制，八进制，十六进制
print('十进制',118)
print('二进制',0b10101111)
print('八进制',0o176)
print('十六进制',0x1EAF)
​
#浮点类型float
a=1.1
b=2.2
print(a,type(a))
print(a+b)#由于计算机使用2进制，所以计算float有可能产生问题，采用下面加模块方法解决
​
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))
​
#布尔类型bool
f1=True
f2=False
print(f1,type(f1))
print(f2,type(f2))
#bool可以转成整数计算
print(f1+1)  #1+1  True-->1
print(f2+1)  #0+1  False-->0
​
#字符串类型str
str1='你好'
str2="你好"
str3="""你
好"""              #使用3引号，可以跨行
str4='''你
好'''
print(str1,type(str1))
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))

3. 数据类型强制转换

#3个转换函数 str()   int()   float()
name='张三'
age=20
​
print(type(name),type(age))
#不同数据类型 不能连接（+）在一起
#print('我叫'+name+'今年'+age+'岁') 这里报错
print('我叫'+name+'今年'+str(age)+'岁')  #这里用str(age)强制转换
​
#注意：
#转换成str:可以用单引号（''）转换（与str()作用一样）
​
#float转int：忽略小数部分
#bool转int：True转成1，False转成0
#str转int: 必须为数字串（不能为其它文字类的），且不能为小数串
​
#str转float:必须为数字串
#int转float:自动加 .0

4. 关键字keyword

import keyword
print(keyword.kwlist)
​
#注意：
#1.只能由 数字、字母、下划线构成
#2.不能数字开头
#3.不能用 保留字（就是上面输出的 内容）
#4.严格区分大小写

5. 注释

#改编码方式
#coding:utf-8
​
#单行注释
#以 ”#“ 开头，直到 本行结束
​
#多行注释
'''你好，我是
多行注释'''

第3章

1. input函数

#输入函数input
want=input('你想要什么？')
print(want,type(want))
​
#从键盘录入2个整数，计算add
a=input('请输入1个加数')
b=input('请输入另1个加数')
print(a+b) #a和b是str类型，这里+只起到连接作用
print(int(a)+int(b))  #将a和b转换成int,进行加法计算。也可以在print之前就转换

2. 运算符

#算术运算符
print(1+1) #加法运算
print(1-1) #减法运算
print(1*2) #乘法运算
print(11/2) #除法运算
print(11//2) #整除运算 #一正一负的取整公式：向下取整 例如：结果为-2.2，显示 -3
print(11%2) #取余运算  #一正一负的取余公式：余数=被除数-除数*商
print(2**3) #表示2的3次方

#赋值运算符
#执行顺序：从右到左
i=3+4
print(i)
#支持链式赋值
a=b=c=20
print(a,id(a))
print(b,id(b))
print(c,id(c))  #a,b,c指向的同一个空间
#支持参数赋值
a=20
a+=30  #a=a+30
print(a)
a-=10  #a=a-10
print(a)
a*=2
print(a)
print(type(a))
a/=3
print(a)
print(type(a))
a//=2
print(a)
print(type(a))
a%=3
print(a)
#支持系列解包赋值(左右个数 要相同)
a,b,c=10,20,30
print(a,b,c)
a,b,c=b,c,a  #交换变量的值
print(a,b,c)

#比较运算符(结果为bool类型)
a,b=10,20
print('a>b吗？',a>b) #结果：False
print('a<b吗？',a<b) #结果：True
print('a<=b吗？',a<=b) #结果：True
print('a>=b吗？',a>=b) #结果：False
print('a==b吗？',a==b) #结果：False
print('a!=b吗？',a!=b) #结果：True
a=10
b=10
#比较标识
print('a与b的标识相等吗？',a is b) #结果：True
print('a与b的标识相等吗？',a is not b) #结果：False
list1=[1,2,3,4,5]
list2=[1,2,3,4,5]
print(list1==list2)  #比较值  True
print(list1 is list2)  #比较标识  False
print(list1 is not list2)  #比较标识  True

#布尔运算符bool
#5个：and     or    not     in     not in
a,b=1,2
print(a==1 and b==2)  #结果为： True
print(a==1 and b<2)  #结果为： False
print(a!=1 and b==2)  #结果为： False
print(a!=1 and b !=2)  #结果为： False

print(a==1 or b==2)  #结果为： True
print(a==1 or b<2)  #结果为： True
print(a!=1 or b==2)  #结果为： True
print(a!=1 or b!=2)  #结果为： False

f=True
f2=False
print(not f)  #结果为: False
print(not f2)  #结果为: True

s='hello world'
print('w' in s) #结果为：True   in表示：s中包不包含w
print('k' in s) #结果为：False

print('w' not in s) #结果为：False  not in表示：s中包不包含w,然后结果取反
print('k' not in s) #结果为：True

#位运算符
#4个：&    |    <<    >>
print(4&8)  #结果为:0  &运算：化为2进制，然后按位：1&1-->1,其它-->0    只要有一个为0，就为0
print(4|8)  #结果为:12  |运算：化为2进制，然后按位：0&0-->0,其它-->1   只要有一个为1，就为1
print(4<<1) #4向左移动1位 结果为:8    相当于*2
print(4<<2) #4向左移动1位 结果为:16   相当于*4
print(4>>1) #4向右移动1位 结果为:2    相当于/2
print(4>>2) #4向右移动2位 结果为:1    相当于/4


#python运算优先级
#算术运算-->位运算-->比较运算-->bool运算-->赋值运算符     (有括号先算括号)
#                   True/False

第4章

1. pass语句

#pass语句什么都不做，只作一个占位符，用到需要写语句的地方
answer=input('您是会员吗？y/n')

if answer=='y':
    pass
else:
    pass

2. 对象的bool值

print('--------------以下对象的bool值为False,其它对象的bool值为True---------')
print(bool(False))
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())) #空集合

3. 顺序结构

'''把大象装进冰箱，需要几步'''
print('-----------程序开始---------')
print('1.打开冰箱门')
print('2.把大象装进去')
print('3.关上冰箱门')
print('-----------程序结束---------')

4. 选择结构

#单分支结构
'''
if 条件表达式 :
  条件执行体
'''
money=1000 #余额
s=int(input('请输入取款金额')) #取款金额
#判断余额是否充足
if money>=s:
    money=money-s
    print('取款成功，余额为：',money)

#双分支结构
'''
if 条件表达式 :
  条件执行体1
else :
  条件执行体2
'''
num=int(input('请输入一个整数'))
if num%2==0:
    print(num,'是偶数')
else:
    print(num,'是奇数')

#多分支结构
'''
if 条件表达式1 :
  条件执行体1
elif 条件表达式2 :
  条件执行体2
elif 条件表达式N :
  条件执行体N
[else :]
  条件执行体N+1
'''
score=int(input('请输入你的成绩：'))
if score>=90 and score<=100:
    print('A')
elif score>=80 and score<90:
    print('B')
elif 70<=score<80:#python独有的写法
    print('C')
elif score>=60 and score<70:
    print('D')
elif score>=0 and score<60:
    print('E')
else:
    print('成绩无效')

#嵌套if
'''
if 条件表达式1:
  if 内层条件表达式:
      内层条件执行体1
  else:
      内层条件执行体2
else:
  条件执行体
'''
answer=input('您是会员吗？y/n')
money2=float(input('请输入您的购物金额：'))
if answer=='y':
    if money2>=200:
        print('打8折，您的付款金额为：',money2*0.8)
    elif 100<=money2<200:
        print('打9折，您的付款金额为：',money2*0.9)
    else:
        print('不打折，您的付款金额为：',money2)
else:
    if money2>=200:
        print('打9.5折，您的付款金额为：', money2 * 0.95)
    else:
        print('不大折，您的付款金额为：',money2)

#条件表达式
num_a=int(input('请输入第一个整数'))
num_b=int(input('请输入第二个整数'))
'''if num_a>num_b:
    print(num_a,'大于',num_b)
elif num_a<num_b:
    print(num_a,'小于',num_b)
else:
    print(num_a,'等于',num_b)
'''
print(  str(num_a)+'>='+str(num_b)  if (num_a>=num_b)   else   str(num_a)+'<'+str(num_b)  )
#如果 if判断为True,执行前一个语句；判断为False,执行后一个语句

第5章

1. while循环

#语法结构
'''
while 条件表达式:
     条件执行体(循环体)
'''
#四步循环法：初始化变量-->条件判断-->循环体-->改变变量
a=1
while a<10:
    print(a)
    a+=1

#求1.....100的累加和
sum=0
a=1
while a<=100:
    sum+=a
    a+=1
print('100! 等于',sum)

#求1.....100的偶数和
sum=0
a=1
while a<=100:
    if not bool(a%2):    #a%2==0:
        sum+=a
    a+=1
print('1-100间的偶数和为：',sum)

2. for-in循环

#语法结构
'''
for 自定义的变量 in 可迭代对象(字符串、序列等):
     循环体
'''
for item in 'Python': #第1次取出的是P，将P赋值给item，将item的值输出
    print(item)

#range() 产生一个整数序列，也是一个可迭代对象
for i in range(10):
    print(i)

#如果在循环体中，不需要自定义变量，可将自定义变量写为“_”
for _ in range(5):
    print("你好啊")

#使用for循环，计算1-100的偶数和
sum=0
for item2 in range(101):
    if item2%2==0:
        sum+=item2

print('1-100间的偶数和为：',sum)

#输出100-999之间的水仙花数（例子:153=3*3*3+5*5*5+1*1*1）
for item3 in range(100,1000):
    ge=item3%10              #个位上的数
    shi=item3//10%10         #十位上的数
    bai=item3//100           #百位上的数
    #print(bai,shi,ge)

    if ge**3+shi**3+bai**3==item3:
        print(item3)

3. break语句

#用于结束 循环结构，通常与分支结构if一起使用
'''
从键盘录入密码，最多录入3次，如果正确结束循环
'''
for item in range(3):
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')

a=0
while a<3:
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')

4. continue语句

#用于结束 当前循环，进入下一次循环，通常与分支结构if一起使用
'''
要求使用continue语句，输出1-50之间所以5的倍数，5，10，15....
5的倍数的共同点：  和5的余数为0的数
不是5的倍数的共同点：  与5的余数不为0的数
'''
for item in range(1,51):
    if item%5==0:
        print(item)

#使用continue语句
for item2 in range(1,51):
    if item2%5!=0:
        continue
    print(item2)

5. else语句

#1.与if搭配     if条件表达式不成立，执行else
#2.与while搭配  没有碰到break时，执行else
#3.与for搭配    没有碰到break时，执行else

for item in range(3):
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确：')
        break
    else:
        print('密码不正确：')
else:
    print('三次密码全部错误')


a=0
while a<3:
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    a+=1
else:
    print('三次密码全部错误')

6. 循环嵌套

'''
输出一个3行4列的矩形
'''
for i in range(1,4):
    for j in range(1,5):
        print('*',end='\t')  #不换行输出
    print()  #换行


'''
输出“9*9乘法表”
'''
for i in range(1,10):
    for j in range(1,i+1):
        print(i, '*', j, '=', i*j  ,end='\t')
    print()


'''
流程控制语句break和continue在二重循环中：break在内层循环里面，执行break后，只是内层循环退出，外层循环不会退出。continue同理
'''

7. 内置函数range()

#range()的3种创建方式
'''
第1种，只有1个参数（小括号里只给一个数）
'''
r=range(10)  #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]   默认从0开始，默认相差1 称为步长,到10（不包含10）结束
print(r)  #结果：range(0,10)
print(list(r)) #用于查看range对象的整数序列   ---->list是列表的意思

'''
第2种，给2个参数
'''
r=range(1,10)  #从1开始，默认相差1 称为步长,到10（不包含10）结束
print(list(r)) #[1, 2, 3, 4, 5, 6, 7, 8, 9]

'''
第3种，给3个参数
'''
r=range(1,10,2)  #从1开始，默认相差2 称为步长,到10（不包含10）结束
print(list(r)) #[1, 3, 5, 7, 9]

#判断指定的整数在序列中是否存在 in，not in
print(10 in r) #False
print(3 in r) #True

print(10 not in r) #True
print(3 not in r) #False

第6章

1. 列表的创建

a=10 #变量存储的是一个对象的引用

lst=['hello','world',999]
print(id(lst))
print(type(lst))
print(lst)

#list的创建
#第1种，使用 []
lst1=['hello','world',92,'helle']
print(lst1)
print(lst1[0])
print(lst1[0],lst1[-1],lst1[-4],lst1[0])  #输出4个 hello ，且可以存储重复的数据,不同数据类型也可以存储到一个列表中

#第2种，使用内置函数list()
lst2=list(['hello','world',92])
print(lst2)
print(lst2[-3]) #相当于lst2[0]

#空列表的创建
lst=[]
lst=list()

2. 列表的查询

#获取列表中指定元素的索引
lst=['hello','world',98,'hello',234]
print(lst.index('hello'))  #如果有相同的元素，只返回第1个元素的索引
#print(lst.index('Python'))  #如果没有该元素，报错，返回不存在
#print(lst.index('hello',1,3))  #ValueError: 'hello' is not in list
print(lst.index('hello',1,4))  #在索引1到索引4之间查找（不包括索引4）



#获取列表中的单个元素
'''
正向索引：0------->N-1
逆向索引：-N------> -1
'''
lst1=['hello','world',98,'hello',234]
print(lst1[2])  #98
print(lst1[-3]) #98
#获取索引为10的元素
#print(lst[10])  #IndexError: list index out of range   报错，超出范围



#获取列表多个元素
lst2=[10,20,30,40,50,60,70,80]
#start:stop:step     区间：[start,stop)
print(lst2[1:6:1])  # [20, 30, 40, 50, 60]
print('原列表',id(lst2))
lst3=lst2[1:6:1]
print('切的片段:',id(lst3))

#如果不写step(步长)，默认为1
print(lst2[1:6:])
print(lst2[1:6])
#如果不写start,默认从0开始
print(lst2[:6:1])
#如果不写stop，默认到最后一个
print(lst2[1::1])

#如果步长为负数
'''
切片的第一个元素默认为列表的最后一个元素
切片的最后一个元素默认为列表的第一个元素
从start开始，往前切片
'''
print(lst2[::1])  #原列表输出   [10, 20, 30, 40, 50, 60, 70, 80]
print(lst2[::-1])  #逆序输出了  [80, 70, 60, 50, 40, 30, 20, 10]



lst4=[10,20,'hello']
#判断指定元素是否在列表中
print(10 in lst4)            #True
print(100 in lst4)           #Fasle
print('hello' in lst4 )      #True
print(10 not in lst4)        #Fasle
print(100 not in lst4)       #True
print('hello' not in lst4 )  #Fasle
#列表元素的遍历
for item in lst4:
    print(item)

3. 列表的增加

#向列表末尾添加1个元素append()
lst=[10,20,30]
print('添加元素之前：',lst,id(lst))
lst.append(100)
print('添加元素之后：',lst,id(lst))

#向列表末尾添加至少一个元素extend()
lst2=['hello','world']
#lst.append(lst2)  #将lst2当作一个元素，添加到末尾   [10, 20, 30, 100, ['hello', 'world']]
lst.extend(lst2)  #向末尾追加多个元素   [10, 20, 30, 100, 'hello', 'world']
print(lst)

#在列表任意一个位置，插入1个元素insert()
lst.insert(1,90)  #在索引为1的位置上添加90，后面元素的索引顺移下去   [10, 90, 20, 30, 100, 'hello', 'world']
print(lst)

#在列表的任意位置添加至少一个元素 切片方法
lst3=[True,False,'hello']
lst[1:]=lst3  #从索引1的位置开始，切掉到最后一个元素，然后添加lst3的元素
print(lst)

4. 列表的删除

lst=[10,20,30,40,50,30]
lst.remove(30)   #从列表中移除1个元素，如果是重复的，移除第1个
#lst.remove(300)  #如果要移除的元素不存在，报错  ValueError: list.remove(x): x not in list
print(lst)

#根据索引移除元素 pop()
lst.pop(1)  #移除索引为1的元素     如果要移除的索引位置不存在，将报错
print(lst)
lst.pop()   #不加参数，移除最后一个元素
print(lst)

#一次至少删除一个元素  切片方法
# #产生了新的列表对象
lst2=lst[1:3]
print('原列表',lst)
print('切片后的列表',lst2)
#不产生新的列表对象，删除原列表的内容
lst[1:3]=[]  #用空列表 替代
print(lst)

#清空列表clear()
lst.clear()
print(lst)
#删除列表del()
del lst
print(lst)  #这里会报错，因为删除了列表，不能输出了

5. 列表的修改

lst=[10,20,30,40,50]
print(lst)

#一次修改一个值
lst[1]=100   #索引位置为1的值修改为100
print(lst)

#修改多个值  切片方法
lst[2:4]=[200,300,400]
print(lst)

6. 列表的排序

lst=[20,47,23,6,70]
print('排序前的列表：',lst)

#调用sort()方法  默认升序排序
lst.sort()
print('排序后的列表:',lst)
#通过指定 关键字参数，将列表进行降序排序
lst.sort(reverse=True)  #reverse=True,表示降序
print(lst)
lst.sort(reverse=False) #reverse=False,表示降序
print(lst)

#调用内置函数sorted()  与上面的区别：将产生新的列表对象
lst=[20,47,23,6,70]
newlst=sorted(lst)
print(lst)
print(newlst)
#通过指定 关键字参数，将列表进行降序排序
desclst=sorted(lst,reverse=True)  #reverse=True,表示降序
print(desclst)

7. 列表生成式

'''
列表生成式：
语法格式：listname=[i*i for i in range(1,9)]
解释： i*i-->表示列表元素表达式   i-->自定义变量   range(1,9)-->可迭代对象
'''
lst=[i for i in range(1,10)]
print(lst)

lst=[i*i for i in range(1,10)]
print(lst)

#列表中的元素显示2，4，6，8，10
lst2=[i*2 for i in range(1,6)]
print(lst2)

第7章

1. 字典的创建

'''
使用花括号创建
'''
scores={'张三':100,'李四':70,'王二':45}
print(scores)
print(type(scores))  #字典类型

'''
使用dict()创建
'''
student=dict(name='Bob',age=20)
print(student)

'''
空字典的创建
'''
d={}
d=dict()

2. 键(key)的判断

scores={'张三':100,'李四':70,'王二':45}

print('张三' in scores)  #True
print('张三' not in scores)  #False

3. 字典元素的获取

scores={'张三':100,'李四':70,'王二':45}

'''
第一种方式，使用[]
'''
print(scores['张三'])  #100
#print(scores['陈六'])  #KeyError: '陈六'  报错
'''
第二种方式，使用get()方法
'''
print(scores.get('张三'))  #100
print(scores.get('陈六'))  #None
print(scores.get('麻七',999))  #999是在查找'麻七'所对应的value值不存在时，提供的默认值

4. 字典元素的增删改

scores={'张三':100,'李四':70,'王二':45}
print(scores)

del scores['张三']  #删除指定的键值对
print(scores)
#scores.clear()    #清空字典的所有元素
print(scores)

scores['陈六']=95   #新增元素
print(scores)

scores['陈六']=88   #修改元素
print(scores)

5. 获取字典的视图

scores={'张三':100,'李四':70,'王二':45}

#获取所有的键key
keys=scores.keys()
print(keys)
print(type(keys))

#获取所有的值value
values=scores.values()
print(values)
print(type(values))

#获取所有的key-value
items=scores.items()
print(items)
print(type(items))

print(list(items))  #转换之后的列表元素是由 元组 组成

6. 字典的特点

#1.key不允许重复，value允许重复

d={'name':'张三','name':'李四'}  #key不允许重复
print(d)  #{'name': '李四'}

d={'name':'张三','nickname':'张三'}  #value允许重复
print(d)  #{'name': '张三', 'nickname': '张三'}

'''
2.字典中的元素是无序的
3.字典中的key是不可变对象
4.字典使用之前可以不分配空间，自动动态伸缩
5.字典会浪费较大的内存，是一种空间换时间的数据结构
'''

7. 字典生成式

'''
字典生产式：
{      item: price for          item,price    in zip(items,prices)}
表示字典key: value的表达式  自定义表示key，value的变量      可迭代对象

如果两个长度不相等，zip会以 长度短的  生成
'''

items=['A','b','C']
prices=[50,60,70]

d={item:price for item,price in zip(items,prices)}
print(d)

第8章

1. 元组的创建

#第一种，使用 ()
t=('Python','world',78)
print(t)
print(type(t))

t2='Python','world',78  #省略了小括号
print(t2)
print(type(t2))


#第二种，使用内置函数 tuple()
t1=tuple(('Python','world',78))
print(t1)
print(type(t1))

'''
注意：
只包含一个元组需要使用逗号和小括号,如果不加的话会认为是数据本身的类型
t=('hello',)
t=(10,)
'''

#空元组的创建
t4=()
t4=tuple()


'''
1.如果元组中的对象 本身是不可变对象，则不能再引用其它对象
2.如果元组中的对象 是可变对象（列表等）， 则可变对象的引用不允许改变，但数据可以改变。  意思，list本身不可以被改变成一个数，但list里面的数据可以修改
'''

2. 元组的遍历

t=('Python','world',78)

'''
第一种获取元组元素的方式，使用索引
'''
print(t[0])
print(t[1])
print(t[2])

'''
遍历元组
'''
for item in t:
    print(item)

3. 集合的创建

'''
集合是 没有 value 的 字典
'''

'''
第一种，使用 {}
'''
s={2,3,4,4,5,6,7,7}   #集合中的元素不允许重复
print(s)  #输出：{2, 3, 4, 5, 6, 7}

'''
第二种，使用内置函数set()
'''
s1=set(range(6))
print(s1,type(s1))

s2=set([10,20,30,30,50,70])   #集合中的元素是 无序 的
print(s2,type(s2))

s3=set((10,20,30,20,30,40,50,60))
print(s3,type(s3))

s4=set('Python')
print(s4,type(s4))

s5=set({1,2,3,3,4,5,6,33})
print(s5,type(s5))

'''
定义空集合  不能用：s6={},这代表 空字典
'''
s6=set()

4. 集合的相关操作

s={1,2,3,4,555,65,9}

'''
集合元素的判断操作
'''
print(555 in s)  #True
print(555 not in s)  #False


'''
集合元素的新增操作
'''
s.add(77)
print(s)
s.update({111,222,333})
print(s)
s.update([99,88,77])
s.update((22,33,44))
print(s)


'''
集合元素的删除操作
'''
s.remove(1)
print(s)
#s.remove(10000)  #要移除元素不存在的话会报错  KeyError: 10000

s.discard(2)
print(s)
s.discard(10000)  #要移除元素不存在的话 不会 报错

s.pop()  #随机删除 一个数   不能有参数
print(s)

s.clear()  #清空集合中的元素
print(s)

5. 集合之间的关系

'''
两个集合是否相等。   元素相同就相同，无序的
'''
s={10,20,30,40}
s2={30,40,20,10}

print(s==s2)  #True
print(s!=s2)  #False

'''
一个集合是否为另一个集合的子集
'''
s1={10,20,30,40}
s2={10,20,30}
s3={10,90}

print(s2.issubset(s1))  #True
print(s3.issubset(s1))  #False

'''
一个集合是否为另一个集合的超集
'''
print(s1.issuperset(s2))  #True
print(s1.issuperset(s3))  #False

'''
两个集合是否有交集
'''
print(s2.isdisjoint(s3))  #False  代表 有交集
s4={100,200,300}
print(s2.isdisjoint(s4))  #True   代表 无交集

6. 集合之间的数学操作

s1={10,20,30,40,50}
s2={30,40,50,60,70,80}

#交集操作
print(s1.intersection(s2))
print(s1 & s2)

#并集操作
print(s1.union(s2))
print(s1 | s2)

#差集操作
print(s1.difference(s2))  # s1-s2,s1有的s2没有
print(s1 - s2)

#对称差集操作
print(s1.symmetric_difference(s2))   #s1和s2的 并集 减去 交集
print(s1 ^ s2)

7. 集合生成式

'''
集合生成式：(与列表生成式相似，把[]换成{})
语法格式：{i*i for i in range(10)}
解释： i*i-->表示集合元素的表达式   i-->自定义变量   range(10)-->可迭代对象
'''
s={i*i for i in range(10)}   #错乱的0-9的平方
print(s)  #{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}




'''
列表、字典、元组、集合的总结：
数据结构   是否可变   是否重复   是否有序   定义符号

列表list    可变     可重复       有序      []
元组tuple  不可变    可重复       有序      ()
字典dict    可变     key不可重复  无序  {key:value}
                   value可重复 
集合set     可变     不可重复     无序       {}
'''

第9章

1. 字符串的驻留机制

a='Python'
b="Python"
c='''Python'''
print(a,id(a)) #Python 1963572479152
print(b,id(b)) #Python 1963572479152
print(c,id(c)) #Python 1963572479152  3个指向同一个空间，发生了 驻留(对相同的字符串只保留一份拷贝)，即a产生了Python后,b不会创建新的，直接指向Python

'''
驻留机制的几种情况：
1.字符串长度为0/1，可以驻留
2.符合标识符（字母、数字、下划线构成的）的字符串
3.字符串只在编译时进行驻留，而非运行时
4.[-5,256]之间的整数数字
'''

2. 字符串的查询

s='hello,hello'
print(s.index('lo'))  #3
print(s.find('lo'))   #3    'lo'第一次出现的位置
print(s.rindex('lo')) #9
print(s.rfind('lo'))  #9    'lo'最后一次出现的位置

'''
index和find差别：查询不存在的内容，index会报错；而find会return -1
'''

3. 字符串的大小写转换

s='hello,python'

a=s.upper()       #转成大写之后，会产生新的对象
print(a,id(a))
print(s,id(s))

print(s.lower(),id(s.lower()))       #转成小写之后，也会产生新的对象
print(s,id(s))

s2='hello,Python'
print(s2.swapcase())    #HELLO,pYTHON    大写变小写，小写变大写
print(s2.title())       #Hello,Python    每个单纯 第一个变大写，其余变小写

4. 字符串的内容对齐

s='hello,Python'

'''居中对齐'''
print(s.center(20,'*'))   # ****hello,Python****
print(s.ljust(20,'*'))    # hello,Python********
'''左对齐'''
print(s.ljust(10))        # hello,Python
print(s.ljust(20))        # 'hello,Python        ' #不写填充符号，默认为空格
'''右对齐'''
print(s.rjust(20,'*'))    # ********hello,Python
print(s.rjust(20))        #         hello,Python   #不写填充符号，默认为空格
'''右对齐，只有1个参数，默认使用0填充'''
print(s.zfill(20))        # 00000000hello,Python
print(s.zfill(10))        # hello,Python
print('-8910'.zfill(8))   # -0008910  加上-，共算成8位

5. 字符串的劈分

s='hello world Python'
lst=s.split() #['hello', 'world', 'Python']   默认空格为 分隔符
print(lst)
s1='hello|world|Python'
print(s1.split(sep='|'))  #['hello', 'world', 'Python']    自己设置'|'为空格符
print(s1.split(sep='|',maxsplit=1))  #['hello', 'world|Python']   从左侧 开始，只劈分 1次


'''从右侧开始劈分，rsplit()'''
print(s.rsplit())  #['hello', 'world', 'Python']
print(s1.rsplit('|'))  #['hello', 'world', 'Python']
print(s1.rsplit('|',maxsplit=1))  #['hello|world', 'Python']   从右侧 开始，只劈分 1次

6. 字符串的判断方法

'''
函数                        作用
isidentifier()             判断指定的字符串 是不是为 合法的标识符
isspace()                  判断指定的字符串 是不是由 全部空白字符 组成（回车、换行、水平制表等）
isalpha()                  判断指定的字符串 是不是由 全部由字母 组成
isdecimal()                判断指定的字符串 是不是由 全部十进制的数字 表示
isnumeric()                判断指定的字符串 是不是由 全部数字 组成
isalnum()                  判断指定的字符串 是不是由 字母和数字 组成
'''

7. 字符串的替换和合并

s='hello,Python'
print(s.replace('Python','Java'))  #hello Java   用Python去替换Java
s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',2))  #hello,Java,Java,Python  最多替换2次


lst=['hello','Java','Python']
print('|'.join(lst))   #hello|Java|Python   用'|'去连接
print(''.join(lst))    #helloJavaPython     用''去连接

t=('hello','Java','Python')
print(''.join(t))      #helloJavaPython

print('*'.join('Python'))   #P*y*t*h*o*n

8. 字符串的比较操作

print('apple'>'app')  #True
print('apple'>'banana')  #False

print(ord('a'),ord('b'))   #97 98  ord()获取原始值:a-->97   b-->98
print(chr(97),chr(98))     #a b    chr()获取原始值对应代表的字符：97-->a    98-->b

'''==与is的区别'''
#    ==比较的是 value
#    is比较的是 id是否相等

9. 字符串的切片操作

s='hello,Python'

s1=s[:5]   #默认从0开始切，切到5（不包括5）
print(s1)
s2=s[6:]   #从6开始切，默认到最后一个
print(s2)
s3='!'
newstr=s1+s2+s3  #连接s1、s2、s3
print(newstr)

print('----------------------------------------------------------')
print(id(s),id(s1),id(s2),id(newstr))


print('-------------------切片：[start:stop:step]-----------------')
print(s[1:5:1])  #从1开始切到5（不包括5）
print(s[::2])    #默认从0开始，默认到最后一个结束，步长为2（即2个元素之间索引间隔为2）
print(s[::-1])   #nohtyP,olleh  默认从最后一个开始，到第一个结束，因为步长为负数
print(s[-6::1])  #Python    从索引-6开始，到最后一个结束

10. 格式化字符串

name = '张三'
age = 20

#1.使用%
print('我叫%s,今年%d岁了'  % (name,age))

#2.使用{}
print('我叫{0},今年{1}岁'.format(name,age))

#3.使用f-string
print(f'我叫{name},今年{age}岁')


print('%10d' % 99)          #        99 #10表示的是整个宽度（加上99之后为10）
print('%.3f' % 3.1415926)   #3.142 #保留3为小数
print('%10.3f' % 3.1415926) #     3.142 #同时保持宽度和精度

print('{}'.format(3.1415926)) #3.1415926
print('{:.3}'.format(3.1415926)) #3.14 #表示一共是3位
print('{0:.3}'.format(3.1415926)) #3.14 #表示一共是3位
print('{0:.3f}'.format(3.1415926)) #3.142 #表示3位小数
print('{0:10.3f}'.format(3.1415926)) #    3.142 #表示宽度和精度，一共是10位，小数占3位

11. 字符串的编码转换

s='天涯共此时'
'''编码'''
print(s.encode(encoding='GBK'))    #b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'  #GBK编码:一个中文占2个字节
print(s.encode(encoding='UTF-8'))  #b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'  #UTF-8编码：一个中文占3个字节
'''解码'''
#byte代表就是一个二进制数据（字节类型的数据）
byte=s.encode(encoding='GBK')      #编码
print(byte.decode(encoding='GBK')) #解码  不能用GBK去编，用UTF-8去解码

第10章

1. 函数的创建和调用

'''
创建格式：
def 函数名（[输入参数]）:
     函数体
     [return xxx]

调用格式： 函数名([实际参数])
'''
def calc(a,b):   #a、b称为形参，在函数的定义处
    global c     #使用gloabl声明，可将局部变量 变成 全局变量
    c=a+b        #c是局部变量
    return c

'''参数传递'''
#1.根据 形参的位置顺序 进行实参传递
#2.根据 形参名称      进行实参传递

result=calc(10,20)  #10、20称为实参，在函数的调用处
print(result) #30

res=calc(b=20,a=10)  #关键字参数
print(res)  #30

'''
在函数调用过程中，进行参数的传递时

如果是 不可变对象， 在函数体内的修改不会影响实参的值
如果是 可变对象（列表等）， 在函数体的修改会影响到实参的值
'''

2. 函数的返回值

'''
函数的返回值
1.如果函数没有返回值，return可以省略不写
2.如果函数返回值是1个，直接返回 且类型与原数据类型相同
3.如果函数返回类型是多个，返回的结果为元组
'''
#举例：
#1.
def func1():
    print('hello')
   #return

func1() #无返回值的话，return可以省略不写
#2.
def func2():
    return 'hello'

re=func2()
print(re)  #直接返回 且类型与原数据类型相同
#3.
def func3():
    return 'hello','world'

print(func3())  #返回的结果为元组

3. 函数的默认值参数

def func(a,b=10):  #b称为默认参数值参数
    print(a,b)

func(100)    #100,10
func(80,70)  #80,70

4. 函数的参数定义

'''
不确定参数个数时，
使用'''

#个数可变的位置参数
def func(*args):  #函数定义时的 个数可变的位置参数。结果为元组
    print(args)

func(10,20)           #(10, 20)
func(1,2,3,4,5)       #(1, 2, 3, 4, 5)

#个数可变的关键字参数
def func1(**args):  #函数定义时的 个数可变的关键字参数。结果为字典
    print(args)

func1(a=10)            #{'a': 10}
func1(a=20,b=30,c=40)  #{'a': 20, 'b': 30, 'c': 40}


'''
函数参数定义时，不能 重复使用 位置参数(*args) 或者关键字参数(**args),   但是可以2种一起使用,并且(*args)必须放在(**args)的前面
'''
def func3(*args1,**args2):
    pass

第11章

1. 类的创建

'''
格式：
class Student:     #Student为类名，由1个或多个 单词组成，每个单词 首字母大写，其余小写     一种规范
    pass

组成：
    类属性
    实例方法
    静态函数
    类方法
'''

class 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('这是静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('这是类方法')

2. 类的实例化

#类的声明
class 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('这是静态方法')

    #类方法
    @classmethod
    def cm(cls):
        print('这是类方法')


#创建Student类的对象
stu1=Student('张三',20)
stu1.eat()
print(stu1.name)
print(stu1.age)
Student.eat(stu1)  #与 stu1.eat() 作用相同

print('------------------')

#类属性的使用方式
stu2=Student('李四',20)
stu3=Student('王五',20)

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()

3. 类的动态绑定属性和方法

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('------stu1动态绑定性别属性--------')
stu1.gender='女'
print(stu1.name,stu1.age,stu1.gender)
print(stu2.name,stu2.age)   #stu2不能调用stu1的gender属性

print('------stu1动态绑定show方法--------')
def show():
    print('这是一个函数')

stu1.show=show
stu1.show()
#stu2不能调用show方法

第12章

1. 面向对象三大特征

'''
面对对象三大特征：
1.封装
提高安全性
2.继承
提高复用性
3.多态
提高可扩展性和可维护性
'''

2. 封装

#封装
class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age   #年龄不希望在类外部被使用，所以加2个_
    def show(self):
        print(self.name,self.__age)

stu=Student('张三',20)
stu.show()

#在类的外部使用name和age
print(stu.name)
#print(stu.__age)  #AttributeError: 'Student' object has no attribute '__age'
print(dir(stu))   #查看指定对象的所有属性
print(stu._Student__age)   #使用dir函数找到 _Student__age  ，进行访问

3. 继承

'''
语法格式：
class 子类类名(父类1，父类2...) :
    pass
'''
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()的方法调用父类的__init__(name,age)方法，把name和age传入
        self.stu_no=stu_no

class Teacher(Person):
    def __init__(self,name,age,tea_year):
        super().__init__(name,age)
        self.tea_year=tea_year

stu=Student('张三',20,1001)
tea=Teacher('李四',30,10)

stu.info()
tea.info()


'''多继承'''
class A(object):
    pass

class B(object):
    pass

class C(A,B):
    pass

4. 方法重写

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)
        self.stu_no=stu_no
    def info(self):   #重写父类Person的info函数
        super().info()    #调用父类的info
        print('学号',self.stu_no)

class Teacher(Person):
    def __init__(self,name,age,tea_year):
        super().__init__(name,age)
        self.tea_year=tea_year
    def info(self):   #重写父类Person的info函数
        super().info()    #调用父类的info
        print('教龄',self.tea_year)


stu=Student('张三',20,1001)
stu.info()

print('-------------------------')
tea=Teacher('李四',30,10)
tea.info()

5. 多态

class Animal(object):
    def eat(self):
        print('动物会吃')

class Dog(Animal):
    def eat(self):
        print('狗吃骨头')

class Cat(Animal):
    def eat(self):
        print('猫吃鱼')

class Person:
    def eat(self):
        print('人吃五谷杂粮')

#定义一个函数
def fun(obj):
    obj.eat()

#调用函数
fun(Cat())
fun(Dog())
fun(Animal())
print('----------------')
fun(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)

print(x.__dict__)   #实例对象的 属性字典
print(C.__dict__)

print('---------------')
print(x.__class__)  #对象所属的类
print(C.__bases__)  #C类的父类的元组
print(C.__base__)   #<class '__main__.A'>    因为A在B前面，定义的时候
print(C.__mro__)    #类的层次结果，查看继承关系
print(A.__subclasses__())   #查看子类

7. 特殊方法

class Student:
    def __init__(self,name):
        self.name=name
    def __add__(self, other): #实现了2个对象的加法运算
        return self.name+other.name
    def __len__(self):  #实现了对象的长度
        return len(self.name)

stu1=Student('Jack')
stu2=Student('李四')

s=stu1+stu2 #实现了2个对象的加法运算（因为在Student类中，编写了__add__()特殊的方法）
print(s)
print('----------------------------------------------')
print(len(stu1))  #实现了对象的长度

print('----------------------------------------------')
class Person:
    def __new__(cls, *args, **kwargs):                               #创建对象
        print('__new__被调用执行了，cls的id值为{0}'.format(id(cls)))
        obj=super().__new__(cls)
        print('创建的对象id为：{0}',format(id(obj)))
        return obj

    def __init__(self,name,age):                                     #对象初始化
        print('__init__被调用了，self的id值为：{0}'.format(id(self)))
        self.name=name
        self.age=age

print('object的这个类对象的id为：{0}'.format(id(object)))
print('Person的这个类对象的id为：{0}'.format(id(Person)))

#创建Person的实例对象
p1=Person('张三',20)
print('Person的这个类对象的id为：{0}'.format(id(p1)))

8. 变量的赋值与深浅拷贝

class CPU:
    pass

class Disk:
    pass

class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk

#1.变量的赋值
cpu1=CPU()
cpu2=cpu1   #内存地址与cpu1相同
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))

print('-----------------------------------')
#2.类的浅拷贝
disk=Disk()   #创建一个硬盘类对象
print(disk)
computer1=Computer(cpu1,disk)   #创建一个计算机类的对象
#浅拷贝：拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象
import  copy
computer2=copy.copy(computer1)
print(computer1,computer1.cpu,computer1.disk)
print(computer2,computer2.cpu,computer2.disk)

print('------------------------------------')
#3.类的深拷贝
#深拷贝：拷贝时，对象本身以及包含的子对象内容 都拷贝了
computer3=copy.deepcopy(computer1)
print(computer1,computer1.cpu,computer1.disk)
print(computer3,computer3.cpu,computer3.disk)

第13章

1. 导入模块

'''
模块的定义：
一个.py文件就是一个模块，
一个模块可包含函数、类、变量、语句等，
一个类包含类属性、类方法、实例方法等。
'''
#第1种导入，将math 内的全部导入
import  math  #引用 数学模块
print(id(math),type(math))
print(math)
print(math.pi)  #3.141592653589793   #输出 数学模块的 π值
print('--------------------------')
print(dir(math))   #查看 math内有哪些函数
print(math.pow(2,4)) #16.0
print(math.ceil(9.003))  #10
print(math.floor(9.003)) #9

print('--------------------------')

#第2种， 只导入 math中的一种
from math import pi  #只导入了math里的 π，不能使用其它函数
print(pi)   #3.141592653589793


#导入自定义模块,这里导入calc.py文件
'''先在目录下，这里指“第13章” 右键，选择“将目录标记为”，点击“源 根”。然后用import导入，这样就可以使用calc的模块
'''
import calc
print(calc.add(3,4))

#导入自定义模块内的一个函数。使用 from ... import ...
from calc import add
print(calc.add(2,8))


'''
Python常用的内置模块
模块名            描述
sys              与Python解释器及其操作环境有关的标准库
time             与时间相关的各种函数的标准库
os               提供访问操作系统服务功能的标准库
calendar         提供与日期的各种函数的标准库
urllib           用于读取来自网上（服务器）的数据的标准库
json             用于使用JSON序列化和反序列化对象
re               用于字符串中执行正则表达式匹配和替换
math             提供标准算术运算函数的标准库
decimal          用于进行精确控制运算精度、有效位数和四舍五入操作的十进制运算
logging          提供了灵活的记录事件、错误、警告、调试信息等日志信息的功能
'''

#第三方模块安装，进入cmd,输入  pip install 模块名

2. 以主程序方式运行

import calc2
print(calc2.add(20,30))

#代码在calc2

3. 导入包里的模块

'''
一个程序 包含多个包
一个包 包含多个模块，
一个模块可包含函数、类、变量、语句等，
一个类包含类属性、类方法、实例方法等。
'''

#导入 包
'''格式： import 包名.模块名'''
import page1.moduleA #as ma #将导入的模块取一个别名ma
print(page1.moduleA.a)  #10
#print(ma.a)  #10

from page1 import moduleA
from page1.moduleA import a

#注意：使用import导入时，只能跟包名或模板名
#     使用from...import... 可以导入包、模块、函数、变量等

上述使用的calc、calc2函数

#calc函数：
def add(a,b):
    return a+b
def sub(a,b):
    return a-b
  
#calc2函数：
def add(a,b):
    return a+b

def sub(a,b):
    return a-b

if __name__ == '__main__':
    print(add(1, 2))  #只有当点击运行calc2时，才会执行运算

'''如果不加main这一行代码的话，引入calc2模块时，会自动输出print(add(1, 2))这条语句'''

第14章

1. 文件读写操作

#只读
file=open('a.txt','r')   #r--->读取
print(file.readlines())  #读取内容放到一个 列表当中
file.close()

#只写
file=open('b.txt','w')   #w--->写入     如果文件没有，则会创建文件；如果有该文件，将会把原本的内容替换成我们写入的内容
file.write('hello world')
file.close()

#追加 写入
file=open('b.txt','a')   #a--->追加写入  如果文件没有，则会创建文件；如果有该文件，将会在原内容末尾 追加我们写入的内容
file.write('Python')
file.close()

#b 以二进制方式打开文件，不能单独使用，需要与其它模式一起使用， rb 或者 wb

#+ 以读写方式打开，不能单独使用，需要与其它模式一起使用，a+

2. 文件对象的常用方法

#读的方法
file=open('a.txt','r')
#print(file.read())    #读取全部
#print(file.read(2))   #读取前2个字符
#print(file.readline()) #读取一行
#print(file.readlines()) #把文本每一行都作为独立的字符串对象，并将这些对象用列表返回
'''
file.seek(2)  #指针移动2个字节（1个汉字占两字节）
print(file.read())
'''
#print(file.tell()) #返回当前指针位置
file.close()


#写的方法  w或者a
file=open('c.txt','a')
#file.write('hello')
#lst=['java','go','python']
#file.writelines(lst)   #将lst列表追加在文本文件，不添加换行符
file.close()


#连续写入
file=open('d.txt','w')
file.write('hello')
file.flush()
file.write('world')
file.close()   #d.txt内容为helloworld

3. with语句

'''使用with语句,结束之后自动关闭，不用再手写 close()函数了'''

with open('a.txt','r') as file:
    print(file.read())

4. os模块

#os模块与操作系统有关的一个模块

import  os
#os.system('notepad.exe')  #打开系统记事本
#os.system('calc.exe')     #打开计算器
#直接调用可执行文件
#os.startfile('C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe')  #edge浏览器的目录，打开edge浏览器

#操作目录相关函数
print(os.getcwd())  #当前的操作路径  E:\PythonCode\python教程\第14章

lst=os.listdir('../第14章')   #返回第14章的所有文件和目录信息
print(lst)    #['1.文件读写操作.py', '2.文件对象的常用方法.py', '3.with语句.py', '4.os模块.py', 'a.txt', 'b.txt', 'c.txt', 'd.txt']

#os.mkdir('newdir')  #创建名叫newdir的目录
#os.makedirs('A/B/C')  #创建多级目录 A包含B，B包含C
#os.rmdir('newdir')  #删除newdir目录
#os.removedirs('A/B/C') #删除多级目录

#os.chdir(path)  将path设置成当前工作目录，path改成自己的路径

5. os.path模块

import os.path

#print(os.path.abspath('4.os模块.py'))  #获取绝对路径  E:\PythonCode\python教程\第14章\4.os模块.py
#print(os.path.exists('4.os模块.py'),os.path.exists('6.xxxx'))  #判断文件或者目录是否存在  True False
#print(os.path.join(path1,path2))   #将目录与目录或者文件名 拼接起来  path1在path2的前面
#print(os.path.split(path)) #将path的目录与文件进行拆分
#print(os.path.splitext('5.os.path模块.py'))  #将文件拆分成文件名和扩展名
#print(os.path.basename(path))  #把path的文件名提取出来
#print(os.path.dirname(path))   #把path的路径提取出来
#print(os.path.isdir(path))     #判断path是不是目录

6. 实例

import os

#列出指定目录下的所有py文件
path=os.getcwd()
lst=os.listdir(path)
for filename in lst:
    if filename.endswith('.py'):
        print(filename)

#遍历目录里的所有文件
path=os.getcwd()
lst_files=os.walk(path)
for dirpath,dirname,filename in lst_files:
    '''
    print(dirpath)
    print(dirname)
    print(filename)
    print('-----------------------')
    '''
    for dir in dirname:
        print(os.path.join(dirpath,dir))

    for file in filename:
        print(os.path.join(dirpath,file))

    print('-----------------------------')



笔记链接：https://www.bilibili.com/video/BV1wD4y1o7AS?spm_id_from=333.337.search-card.all.click

标签：10,语言,Python,self,lst,print,hello,name
From： https://www.cnblogs.com/swbna/p/17101105.html