本文主要是介绍python初学，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

# 最最基本

## print函数

### 将数据输出文件中

```python
#将数据输出文件中,注意点，1.所指定的盘符存在。2.使用file=fp

fp = open('C:/李林峰/text.txt', 'a+')#如果文件不存在就创建，存在就在文件内容后面继续追加
print('helloworld', file=fp)
fp.close()

#不进行换行输出（输出内容在一行当中）

print（'hello','world','Python')

open的方式是输出到文件当中

print的方式是输出到显示器当中+

不进行换行输出（输出的内容在一行中）

print('hello','world','Python')

常用的转义字符

print('hello\nworld')  # 换行  n->newline
print('hello\tworld')  # 空了三隔
print('helloooo\tworld')  # 空了四隔->tab键
print('hello\rworld')  # world将hello进行了覆盖->return光标移动到本行的开头
print('hello\bworld')  # \是退格back

print('http:\\\\www.bandu.com')
print('老师说：\'大家好\'')

#原字符，不希望字符串中的转义字符起作用，就是用元字串之前加上r或R
print(r'hello\nworld')
#注意事项，最后一个字符不能是反斜杠，可以是两个反斜杠
print(r'hello\nworld\\')

变量的定义和使用

name = '玛利亚'
print(name)
print('标识', id(name))
print('类型', type(name))
print('值', name)

数据类型

·常见的数据类型

·整数类型->int->98

·浮点数类型->float->3.14159

·布尔类型->bool->True,False

·字符串类型->str->人生苦短

整数类型

#整数可以表示二进制，十进制，八进制，十六进制
print('十进制'，118)#默认十进制
print('二进制'，0b1010111)#二进制以0b开头
print('八进制'，0o176)#八进制以0o开头
print('十六进制'，0x1EAF)

浮点类型

n1 = 1.1
n2 = 2.2
print(n1+n2)#3.3000000000000003

from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))#3.3

布尔类型

f1 = True
f2 = False
print(f1,type(f1))#True <class 'bool'>
print(f2,type(f2))#False <class 'bool'>

#布尔值可以转成整数计算
print(f1+1) #2     1+1的结果为2，True表示1
print(f2+1) #1     0+1的结果为2，False表示0

字符串类型

str1 = '人生苦短，我用python'
str2 = "人生苦短，我用python"
str3 = """人生苦短，
我用python"""
str4 = ‘‘‘人生苦短，
我用python’’’
#单引号和双引号定义的字符串必须在一行
print(str1,type(str1))#人生苦短，我用python<class 'str'>
print(str2,type(str2))
#三引号定义的字符串可以分布在连续的多行
print(str3,type(str3))
print(str4,type(str4))

类型转换_str()函数与int()函数

str()函数

name = '张三'
age = 20

print(type(name),type(age))#说明name与age的数据类型不相同
print('我叫'+name+'今年'+age+'岁')#当将str类型与int类型进行链接时，报错，解决方案，类型转换
print('我叫'+name+'今年'+str(age)+'岁')

int()函数

s1 = 128
f1 = 98.7
s2 = '76.77'
ff = True
s3 = 'hello'
print(type(s1), type(f1), type(s2), type(ff), type(s3))
print(int(s1), type(int(s1)))  #将str转成int类型，字符串为数字串
print(int(f1), type(int(f1)))  #float转成int类型，截取整数部分，舍掉小数部分
# print(int(s2), type(int(s2)))  #将str转成int类型，报错，因为字符串为小数串
print(int(ff), type(int(ff)))
#print(int(s3), type(int(s3)))  #将str转成int类型，字符串必须为数字串（整数），非数字串是不允许转换的

float类型转换

#字符串中的数据如果是非数字串，则不允许转换

Python中的注释

#单行注释

"""我是多行注释
"""

Input函数的使用

present = input('大圣想要什么礼物呢')#输入之前程序给你的一个提示语   需要输入回答

input函数的高级使用

a = input('请输入一个加数：')#10
b = input('请输入另一个加数：')#10
print(type(a), type(b))#<class 'str'><class 'str'>
print(a + b)#1020


a = input('请输入一个加数：')#10
b = input('请输入另一个加数：')#10
print(type(a), type(b))#<class 'str'><class 'str'>
print(int(a) + int(b))#30

或者a = int(input('请输入一个加数：'))

运算符

算数运算符

print(1+1)# 加法运算
print(1-1) # 减法运算
print(2*4)# 8 乘法运算
print(1/2)# 除法运算
print(11/2)#5.5 除法运算
print(11//2)# 5 整除运算
print(11%2)# 1 取余运算
print(2**2)# 4 表示的是2的2次方
print(2**3)# 8 表示的是2的3次方

含减号的运算

print(9 // 4)  # 2
print(-9 // -4)  # 2

print(9 // -4)  # -3
print(-9 // 4)  # -3 一正一负的整数公式，向下取整

print(9 % -4)  # -3 余数=被除数-除数*商 9-(-4)*(-3)
print(-9 % 4)  # 3

赋值运算符

#解包赋值
a,b,c=20,30,40
print(a,b,c)
print('-----------交换两个变量的值----------')
a,b=10,20
print('交换之前：',a,b)#交换之前：10 20
#交换
a,b=b,a
print('交换之后:',a,b)#交换之后：20 10

比较运算符

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)#True 说明，a与b的value相等
print(a is b)#True 说明， a与b的id标识相等

#以下代码没学过，后面会给大家讲解
llist1=[11,22,33,44]
llist2=[11,22,33,44]
print(lstr1==lstr2)#value -->True
print(lstr1 is lstr2)#id -->False
print(id(lstr1))#267587787
print(id(lstr2))#787897988
print(lstr1 is not lstr2) #True

布尔运算

#and并且
#or或者
#not 对bool类型操作数取反
f=True
f2=False
print(not f)#False
print(not f2)#True
#in与not in
s = 'helloworld'
print('w' in s)#True
print('k' in s)#False
print('w' not in s)#False
print('k' not in s)#True

位运算

print(4 & 8)  # 0 按位于&,同为1时结果为1
print(4 | 8)  # 12 按位或|，同为0时结果为0
print(4 << 1)  # 8 向左移动1位(移动一个位置)相当于乘以2
print(4 << 2)  # 16 向左移动2位(移动2个位置)

print(4 >> 1)  # 2 向右移动1位，相当于除以2
print(4 >> 2)  # 1 向右移动2位，相当于除以4

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mGcjj80O-1643201540460)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220119175339789.png)]

运算符的优先级

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DxA00Btf-1643201540461)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220119180200590.png)]

对象的布尔值

print(bool(False))#False
print(bool(0))#False
print(bool(0.0))#False
print(bool(None))#False
print(bool(''))#False
print(bool(""))#False
print(bool([]))#False空列表
print(bool(list()))#False空列表
print(bool(()))#False空元组
print(bool(tuple))#False空元组
print(bool({}))#空字典
print(bool(dict()))#False空字典
print(bool(set()))#False空集合

其他的bool值为True
print(bool(18))#True
print(bool('helloworld'))#True

选择结构

单分支结构

money = 1000
s = int((input('请输入取款金额')))#取款金额
#判断金额是否充足
if money>=s:
    money=money-s
    print('取款成功，金额为：',money)

双分支结构

num = int(input('请输入一个整数'))
#条件判断
if num%2==0:
    print(num,'是偶数')
else：
    print(num,'是奇数')

多分支结构

score = int(input('请输入一个成绩：'))
# 判断
if 90 <= score <= 100:
    print('A级')
elif 80 <= score < 90:
    print('B级')
elif 70 <= score < 80:
    print('C级')
elif 60 <= score < 70:
    print('D级')
elif 0 <= score < 59:
    print('E级')
else：
    print('对不起，您输入的成绩有误，不再成绩的有效范围内')

嵌套if的使用

answer=input('您是会员吗？y/n')
money=float(input('请输入您的购物金额：'))
#外层判断是否是会员
if answer=='y':
    if money >= 200：
        print('打八折,付款金额为：',money*0.8)
    elif money>=100:
        print('打九折,付款金额为：',money*0.9)
    else:
        print('不打折,付款金额为：',money)
else:
    if money>=200:
        print('打9.5折,付款金额为：',money*0.95
    else:
        print('不打折，付款金额为：',money)

条件表达式

''''num_a=int(input('请输入第一个整数'))
num_b=int(input('请输入第二个整数'))
#比较大小
if num_a>=num_b
  print(num_a,'大于等于',num_b)
else:
  print(num_a,'小于',num_b)''''
print('使用条件表达式进行比较')
#条件判断的结果为true，就执行左边的内容，为false，执行右侧的代码
print(str(num_a)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于'+str(num_b))

pass语句

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

#判断是否是会员
if answer == 'y':
    pass
else:
    pass

range的三种创建方式

#range()的三种创建方式

''''第一种方式，只有一个参数(小括号中只给一个数)''''
r = range(10) #[0,1,2,3,4,5,6,7,8,9],默认从0开始，默认相差1位步长
print(r)#range(0,10)
print(list(r))#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#用于查看range对象中的整数序列-->list是列表的意思

''''第二中创建方式，给了两个数(小括号中给了连个数)''''
r=range(1,10)#指定了起始值，从1开始，到10结束(不包含10),默认步长为1
print(list(r))#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

''''第三种创建方式,给了三个参数(小括号中给了三个数)''''
r=range(1,10,2)
print(list(r))#[1,3,5,7,9]
'''判断指定的整数在序列中是否存在in,not in'''
print(10 in r)#False,10不在当前的r这个整数系列中
print(9 in r)#True,9在当前的r这个序列中
print(10 not in r)#True

while循环结构

sum=0
a=0
while a<5:
    sum+=a
    a++
print('和为',sum)

while练习题

sum=0
a=1
while a<=100:
    if a%2==0:
        sum+=a
    a+=1
print('1-100之间的偶数和',sum)#因为print和while是对齐的，所以print没有进入while循环

for-in循环

for item in 'Python':#第一次取出来的是P,将P赋值给item,将item的值输出
   print(item)
#range() 产生一个整数序列---》也是一个可迭代对象
for i in range(10):
    print(i)#1 2 3 4 5 6 7 8 9
#如果在循环体中不需要使用自定义白能量，可将自定义变量写为“_”
for _ in range(5):
    print('人生苦短,我用Python')

print('使用for循环,计算1到100的偶数和')
sum=0#用于存储偶数和
for item in range(1,101):
    if item % 2==0:
        sum+=item
  
print('1到100之间的偶数和为：',sum)

输出100到999的水仙花数

for item in range(100, 1000):
    ge = item % 10
    shi = item // 10 % 10
    bai = item // 100

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

循环控制语句break

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

流程控制语句continue

for item in range(1, 51):
    if item % 5 != 0:
        continue
    print(item)

else语句

没有碰到break时执行else

#for和else搭配使用
for item in range(3):
    pwd = input('请输入密码：')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
else:
    print('对不起，三次密码均输入错误')
#while和else搭配使用
a = 0
while a < 3:
    pwd = input('请输入密码')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    a += 1
else:
    print('对不起,三次密码均不正确')

嵌套循环

# 输入一个三行四列的举行
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(str(i) + '*' + str(j) + '=' + str(i * j), end='\t')
#print(i,'*',j,'=',i*j,end='\t')
    print()

二重循环中的break

二重循环中的break和continue用于控制本层循环

列表

自己的感悟

列表让我想到了Excel表，他的括号是直上直下的，又联系到java里的列表就有list([ ])

·列表对应的英语单词是list—>list([])

列表的创建

"""创建列表的第一种方式，使用[]"""
lst = ['hello', 'world', 98]

'''创建列表的第二种方式,使用内置函数list()'''

lst2 = list(['hello', 'world', 98])
print()

列表的特点

1.列表元素按顺序有序排序

2.索引映射唯一一个数据

3.列表可以存储重复数据

4.任意数据类型混存

5.根据需要动态分配和回收内存

获取指定元素的索引

lst = ['hello', 'world', 98, 'hello']
print(lst.index('hello'))  # 如果列表中有相同元素只返回相同元素的第一个元素的索引
# print(lst.index('Python'))  # 'Python' is not in list
# print(lst.index('hello', 1, 3))#'hello' is not in list 在1~2的位置上查找
print(lst.index('hello', 1, 4))

获取列表中的单个元素

正向索引从0到N-1，举例list[0]

逆向索引你从-N到-1，举例lst[-N]

指定索引不存，抛出IndexError

lst = ['hello', 'world', 98, 'hello', 'world', 234]
# 获取索引为2的元素
print(lst[2])  # 98
# 获取索引为-3的元素
print(lst[-3])  # hello
# 获取索引为10的元素
print(lst[10])  # IndexError: list index out of range

列表元素的查询操作

# 判断指定元素在列表中是否存在
print('p' in 'python')
print('k' not in 'python')

lst = [10, 20, 'python', 'hello']
print(10 in lst)  # True
print(100 in lst)  # False
print(10 not in list)  # True

# 遍历
for item in lst:
    print(item)

列表元素的增加操作

# append() 向列表的末尾添加一个元素
lst = [10, 20, 30]
print('添加元素之前', lst, id(lst))  # 添加元素之前 [10, 20, 30] 2100054273728
lst.append(100)
print('添加元素之后', lst, id(lst))  # 添加元素之后 [10, 20, 30, 100] 2100054273728
print(list)  # <class 'list'>
# extend() 在列表的末尾只收添加一个元素
lst2 = ['hello', 'world']
# st.append(lst2)#将lst2作为一个元素添加到列表的末尾
# print(lst)  # [10, 20, 30, 100, ['hello', 'world']]
# 向列表的末尾一次性添加多个元素
lst.extend(lst2)
print(lst)
# 在指定位置上添加一个元素
lst.insert(1, 90)
lst3 = [True, False, 'hello']
# 在任意的位置上添加N多个元素
lst[1:] = lst3;
print(lst)

列表元素的删除操作

lst = [10, 20, 30, 40, 50, 60, 30]
lst.remove(30)  # 从列表中溢出一个元素，如果有重复元素只移第一个元素
print(lst)
lst.remove(100)  # [10, 20, 40, 50, 60, 30]

lst = [10, 20, 30, 40, 50, 60, 30]
# pop()根据索引移除元素
lst.pop(1)
print(lst)
lst.pop(6)
print(lst)  # pop index out of range

lst = [10, 20, 30, 40, 50, 60, 30]
# pop()根据索引移除元素
lst.pop(1)
print(lst)
lst.pop(5)
print(lst)  # pop index out of range
lst.pop()  # 如果不指定参数(索引),将删除列表中的最后一个元素
print(lst)

lst = [10, 20, 30, 40, 50, 60, 30]
print("------切片操作-删除至少一个元素，将产生一个新的列表对象")
new_list = lst[1:3]
print('原列表', lst)#原列表 [10, 20, 30, 40, 50, 60, 30]
print('切片后的列表', new_list)#切片后的列表 [20, 30]

'''不产生新的列表对象，二回删除原列表中的内容'''
lst = [10, 20, 30, 40, 50, 60, 30]
lst[1:3] = []
print(lst)  # [10, 40, 50, 60, 30]

"""清楚列表中的所有元素"""
lst = [10, 20, 30, 40, 50, 60, 30]
lst.clear()
print(lst)

"""del语句将列表对象删除"""
lst = [10, 20, 30, 40, 50, 60, 30]
del lst
print(lst)#name 'lst' is not defined

列表元素的修改操作

lst = [10, 20, 30, 40]
# 一次修改一个值
lst[2] = 100
print(lst)  # [10, 20, 100, 40]
lst[1:3] = [300, 400, 500, 600]  # [10, 300, 400, 500, 600, 40]
print(lst)

列表元素的排序操作

·常见的两种方式

·调用sort()方法，列有中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True，进行降序排序

·调用内置函数sorted(),可以指定reverse=True，进行降序排序，原列表不发生改变

lst = [20, 40, 10, 98, 54]
print('排序前的列表', lst, id(lst))  # 排序前的列表 [20, 40, 10, 98, 54] 3245910544000
# 开始排序,调用列表对象的sort方法,升序排序
lst.sort()
print('排序后的列表', lst, id(lst))  # 排序后的列表 [10, 20, 40, 54, 98] 1433208368896


# 通过指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)  # reverse=True 表示降序排序 reverse=False就是降序排序
print(lst)#[98, 54, 40, 20, 10]
lst.sort(reverse=False)
print(lst)#[10, 20, 40, 54, 98]



# 使用内置函数sorted()对列表进行排序，将产生一个新的列表对象
lst = [20, 40, 10, 98, 54]
print('原列表', lst)
# 开始排序
new_list = sorted(lst)
print(lst)
print(new_list)
# 指定关键字参数,实现列表元素的降序排序
desc_list = sorted(lst, reverse=True)
print(desc_list)

列表生成式

简称生成列表的公式

·语法格式：

​ [i*i for i in range(1,10)]

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]

'''列表元素的值为2,4,6,8,10'''
lst2=[i*2 for i in range(1,6)]
print(lst2)#[2, 4, 6, 8, 10]

字典

自己的感悟

字典嘛，让我想到了老师的棒棒，---->{}，

{‘张三’：100}：冒号显得很随意

字典dictionary，dict(name=‘jack’) ，"="像一个字典横着放在那

·字典对应的英语单词是dict---->dict()

什么是字典

·Python内置的数据结构之一，与列表一样时一个可变序列·以键值对的方式存储数据，字典是一个无序的序列

字典的创建

·最常用的方式：使用花括号

scores={‘张三’：100，‘李四’：98}

·使用内置函数dict()

dict(name=‘jack’,age=20)

"""使用{}创建字典"""
scores = {'张三': 100}
print(scores)  # {'张三': 100}
print(type(scores))  # <class 'dict'>

'''第二种方式dict()'''
student = dict(name='jack', age=20)
print(student)  # {'name': 'jack', 'age': 20}

'''空字典'''
d = {}
print(d)  # {}

字典元素的获取

scores = {'张三': 100, '李四': 98, '王五': 45}

'''第一种方式,使用[]'''
print(scores['张三'])  # 100
# print(scores['陈六'])#KeyError: '陈六'

'''第二种方式,使用get()方法'''
print(scores.get('张三'))  # 100
print(scores.get('陈六'))  # None
print(scores.get('马奇', 99))  # 99   99是在查找’马奇‘所对的value不存在时，提供第一个默认值

字典的增删改操作

"""key的判断"""
scores = {'张三': 100, '李四': 98, '王五': 45}
print('张三' in scores)  # True
print('张三' not in scores)  # False

del scores['张三']  # 删除指定的key-value对
scores.clear()  # 清空字典的元素
print(scores)  # False


#新增元素
scores = {'张三': 100, '李四': 98, '王五': 45}
scores['陈六'] = 98
print(scores)#{'张三': 100, '李四': 98, '王五': 45, '陈六': 98}

#修改元素
scores = {'张三': 100, '李四': 98, '王五': 45, '陈六': 98}
scores['陈六'] = 100
print(scores)

获取字典视图的三个方法

1、keys()------获取字典中所有key

2、values()------获取字典中所有value

3、items()------获取字典中所有key，values

scores = {'张三': 100, '李四': 98, '王五': 45}
# 获取所有的key
keys = scores.keys()
print(keys)  # dict_keys(['张三', '李四', '王五'])
print(type(keys))  # <class 'dict_keys'>
print(list(keys))  # ['张三', '李四', '王五']

# 获取所有的value
values = scores.values()
print(values)  # dict_values([100, 98, 45])
print(type(values))  # <class 'dict_values'>
print(list(values))  # [100, 98, 45]

# 获取所有的key-value对
items = scores.items()
print(items)  # dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
print(list(items))  # [('张三', 100), ('李四', 98), ('王五', 45)]
# 转换之后的列表元素是由元组组成的

字典元素的遍历

scores = {'张三': 100, '李四': 98, '王五': 45}
# 字典元素的遍历
for item in scores:
    print(item, scores[item], scores.get(item))
# 张三 100 100
# 李四 98 98
# 王五 45 45

字典的特点

1、字典中的所有元素都是一个key-value对，key不允许重复，value可以重复

2、字典中的元素是无序的

3、字典中的key必须是不可变对象

4、字典也可以根据需要动态地伸缩

5、字典会浪费较大的内存，是一种使用空间换时间的数据机构

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

d = {'name': '张三', 'nickname': '张三'}  # values可以重复的
print(d)

lst = [10, 20, 30]
lst.insert(1, 100)
print(lst)  # [10, 100, 20, 30

d = {lst: 100}  # unhashable type: 'list'
print(d)
'''不懂，可以再回来看一下'''

字典生成式

items = ['Fruits', 'Books', 'Others']
prices = [96, 78, 85]

d = {item.upper(): price for item, price in zip(items, prices)}
print(d)#{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}

知识点总结

字典的创建

1、使用{}花括号

2、内置函数dict()

3、字典生成式

常用操作

1、获取value

​ ·字典名[key]

​ ·字典名.get(key)

2、删除key-value对

​ del字典名[key]

3、修改/新增

​ 字典名[key]=value

4、in/not

元组

什么是元组

自己的感悟

·元组很圆 所以用（）包住元素，又因为它很圆滑，可以把括号去掉

·元组对应的英语单词是tuple—>tuple(())

·元组

·Python内置的数据结构之一，是一个不可变的序列

·不可变序列与可变序列

·不可变序列与可变序列

·不变序列:字符串、元组

​ ·不可变序列：没有增、删、改的操作

·可变序列：列表、字典

​ ·可变序列：可以对序列执行增、删、改操作，对象地址不发生更改

"""可变序列 列表，字典"""
lst = [10, 20, 45]
print(id(lst))  # 2190449651584
lst.append(300)
print(id(lst))  # 2190449651584


'''不可变序列，字符串，元组'''
s = 'hello'
print(id(s))#3209077469104
s = s + 'world'
print(id(s))#3209077476656
print(s)#helloworld

元组的创建方式

直接小括号

t = (‘Python’，‘hello’,90)

使用内置函数tuple()

t = tuple((‘Python’，‘hello’,90))

只包含一个元组的元素需要使用逗号和小括号

t=(10,)

'''第一种创建方式，使用()'''
t=('Python','world',98)
print(t)  # ('Python', 'world', 98)
print(type(t))  # <class 'tuple'>

'''第二种创建方式,使用内置函数tuple()'''
t2 = 'Python', 'world', 98  # 省略了小括号
print(t2)  # ('Python', 'world', 98)
print(type(t2))  # <class 'tuple'>

t3 = ('Python',)  # 如果元组中只有一个元素，逗号不能省略
print(t3)  # ('Python',)
print(type(t3))  # <class 'tuple'>

'''第二种方式,使用内置函数tuple()'''
t1 = tuple(('Python', 'world', 98))
print(t1)  # ('Python', 'world', 98)
print(type(t1))  # <class 'tuple'>

'''空元组的创建方式'''
'''空列表的创建方式'''
lst = []
lst1 = list()

d = {}
d2 = dict()

# 空元组
t4 = ()
t5 = tuple()

print('空列表', lst, lst1)  # 空列表 [] []
print('空字典', d, d2)  # 空字典 {} {}
print('空元组', t4, t5)  # 空元组 () ()

为什么要把元组设计成不可变序列

·在多任务环境下，同时操作对象时不需要加锁

·因此，在程序中尽量使用不可变序列

注意事项：

元组中存储的是对象的引用

a)如果元组中对象本身不可对象，则不能再引用其它对象

b)如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

t = [10, [20, 30], 9]
print(t)  # (10, [20, 30], 9)
print(type(t))  # <class 'tuple'>
print(type(t[0]), type(t[0]), id(t[0]))  # <class 'int'> <class 'int'> 2155089521232
print(type(t[1]), type(t[1]), id(t[1]))  # <class 'list'> <class 'list'> 2155091275648
print(type(t[2]), type(t[2]), id(t[2]))  # <class 'int'> <class 'int'> 2155089521200
'''尝试将t[1]修改为100'''
print(id(100))
# t[1] = 100 #元组是不允许修改元素的
'''由于[20,30]列表,而列表是可变序列，所以可以向列中添加元素，而列表中的内存地址不变'''
t[1].append(100)  # 向列表中添加元素
print(t,id(t[1]))  # [10, [20, 30, 100], 9]

元组的遍历

t = ('Python', 'world', 98)
'''第一种获取元组的方式，使用索引'''
print(t[0])  # Python
print(t[1])  # world
print(t[2])  # 98
#print(t[3])  # tuple index out of range

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

集合

自己的感悟

集合对应的英语单词是set()

什么是集合

·Python语言提供的内置数据结构

·与列表、字典一样都属于可变类型的序列

·集合是没有value的字典

集合的创建方式

"""第一种创建方式使用{}"""
s = {2, 3, 4, 5, 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([1, 2, 3, 4, 5, 5, 6, 6])
print(s2, type(s2))  # {1, 2, 3, 4, 5, 6} <class 'set'>

s3 = set((1, 2, 4, 4, 5, 65))
print(s3, type(s3))  # {65, 1, 2, 4, 5} <class 'set'>

s4 = set('python')
print(s4, type(s4))  # {'t', 'o', 'n', 'h', 'y', 'p'} <class 'set'>

s5 = set({12, 4, 34, 55, 66, 44})
print(s5, type(s5))  # {34, 66, 4, 55, 12, 44} <class 'set'>

# 定义一个空集合
s6 = {}  # dict字典类型
print(type(s6))  # <class 'dict'>

s7 = set()
print(type(s7))  # <class 'set'>

集合的相关操作

·集合元素的判断操作

·in或not in

·集合元素的新增操作

·调用add()方法，一次添中一个元素

·调用update()方法，至少添中一个元素

·集合元素的删除操作

·调用remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyErrot

·调用discard()方法，一次删除一个指定元素，如果指定的元素不存在不抛异常

·调用pop()方法，一次只删除一个任意元素

·调用clear()方法，清空集合

s = {10, 20, 30, 405, 60}
'''集合元素的判断操作'''
print(10 in s)  # True
print(100 in s)  # False
print(10 not in s)  # False
print(100 not in s)  # True
'''集合元素的新增操作'''
s.add(80)  # add一次添加一个元素
print(s)  # {80, 20, 405, 10, 60, 30}
s.update({200, 400, 300})  # 一次至少添加一个元素
print(s)  # {200, 10, 300, 80, 400, 20, 405, 60, 30}
s.update([100, 99, 8])
s.update((78, 64, 56))
print(s)  # {64, 99, 100, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}

'''集合元素的删除操作'''
s.remove(100)
print(s)  # {64, 99, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
# s.remove(500)#KeyError: 500
s.discard(500)  # {64, 99, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
print(s)
s.pop()
s.pop()
# s.pop(400)#set.pop() takes no arguments (1 given) pop方法不能添加参数
print(s)  # {200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
s.clear()
print(s)  # set()

集合间的关系

两个集合是否相等

·可以使用运算符==或！=进行判断

一个集合是否是另一个集合的子集

·可以调用方法issubset进行判断

·B是A的子集

一个集合是否是另一个集合的超集

·可以调用方法issuperset进行判断

·A是B的超集

两个集合是否没有交集

·可以调用方法isdisjojoint进行判断

"""两个集合是否相等(元素相同,就相等)"""
s = {10, 20, 30, 40}
s2 = {30, 40, 20, 10}
print(s == s2)  # True
print(s != s2)  # False

'''一个集合是否是另一个集合的子集'''
s1 = {10, 20, 30, 40, 50, 60}
s2 = {10, 20, 30, 40}
s3 = {10, 20, 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 #有交集为False
s4 = {100, 200, 300}

print(s2.isdisjoint(s4))  # True 没有交集为True

集合的数据操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BQh13eTs-1643201540462)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220120181531029.png)]

# (1)交集
s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
print(s1.intersection(s2))  # {40, 20, 30}
print(s1 & s2)  # {40, 20, 30}#intersection与&等价,交集操作
# (2)并集操作
print(s1.union(s2))
print(s1 | s2)  # union与|等价,并集操作
print(s1)  # {40, 10, 20, 30}
print(s2)  # {50, 20, 40, 60, 30}
# (3)差集操作
print(s1.difference(s2))  # {10}
print(s1 - s2)  # {10}
print(s1)
print(s2)

# (4)对称差集
print(s1.symmetric_difference(s2))#{50, 10, 60}
print(s1 ^ s2)#{50, 10, 60}

集合生成式

·用于生成集合的公式

{i*i for i in range(1,10)}

·将{}修改为[]j就是列表生成式

·没有元组生成式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ubEqBxLv-1643201540464)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220120221831248.png)]

# 列表生成式

lst = [i * i for i in range(10)]
print(lst)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 集合生成式
s = {i * i for i in range(10)}
print(s)  # {0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

列表字典元组集合的比较

创建

列表
1、lst = [‘hello’, ‘world’, 98]

2、lst2 = list([‘hello’, ‘world’, 98])

字典
1、dit = {‘张三’: 100}

2、dit1 = dict(name=‘jack’, age=20)

元组
1、tup=(‘Python’,‘world’,98)

tup2 = (‘Python’,)

tup3 = ‘Python’, ‘world’, 98

2、tup4 = tuple((‘Python’, ‘world’, 98))

集合

1、s = {2, 3, 4, 5, 5, 6, 7, 7}

2、 s1 = set(range(6))

s2 = set([1, 2, 3, 4, 5, 5, 6, 6])

s3 = set((1, 2, 4, 4, 5, 65))

s4 = set({12, 4, 34, 55, 66, 44})

s5 = set(‘python’)# {‘t’, ‘o’, ‘n’, ‘h’, ‘y’, ‘p’}

索引

列表

获取指定元素的索引

lst = [‘hello’, ‘world’, 98, ‘hello’]
1、print(lst.index(‘hello’))
2、print(lst.index(‘hello’, 1, 4))

获取列表中的单个元素

lst = [‘hello’, ‘world’, 98, ‘hello’, ‘world’, 234]

1、print(lst[2]) # 98
print(lst[-3]) # hello
print(lst[10]) # IndexError: list index out of range

字典元素的获取

scores = {‘张三’: 100, ‘李四’: 98, ‘王五’: 45}

‘’‘第一种方式,使用[]’’’
print(scores[‘张三’]) # 100

print(scores[‘陈六’])#KeyError：‘陈六’

‘’‘第二种方式,使用get()方法’’’
print(scores.get(‘张三’)) # 100
print(scores.get(‘陈六’)) # None
print(scores.get(‘马奇’, 99)) # 99 99是在查找’马奇‘所对的value不存在时，提供第一个默认值

字符串

字符串的创建和驻留机制

字符串的驻留机制

·字符串

​ ·在Python中字符串是基本数据类型，是一个不可变的字符序列

​ 注：第一个不可变的序列是元组，第二个不可变的序列是字符串

·什么叫字符串驻留机制呢？

·仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量

驻留机制的几种情况(交互模式)

·字符串的长度为0或1时

·符合标识符的字符串

s1=''
s2=''
print(s1 is s2)#True
s1='%'
s2='%'
print(s1 is s2)#True
s1='abc%'
s2='abc%'
print(s1==s2)#True 内容相同
print(s1 is s2)#False 地址不相同

·字符串只在编译时进行驻留，而非运行时

a='abc'
b='ab'+'c'
c=''.join(['ab',c])#join的操作是在程序运行的时候，程序在运行的时候当然会开辟一个新的空间
print(a is b)#True
print(a is c)#False
print(c)#abc

·[-5,256]之间的整数数字

a=-5
b=-5
print(a is b)#True
a=-6
b=-6
print(a is b)#False

sys中的intern方法强制2个字符串指向同一个对象

import sys
a='abc%'
b='abc%'
print(a is b)#False
a=sys.intern(b)
print(a is b)#True

PyCharm对字符串进行优化处理

就是之前为值false的结果在PyCharm编译器中是驻留的，是True的

字符串驻留机制的优缺点

·当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，替身效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。

·在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比"+"效率高

字符串的常用操作

字符串的查询操作的方法

查询方法

·index() 查找子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError

·rindex()查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError

·find()查找子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1

·rfind()查找子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pjoysoFO-1643201540465)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220121115056706.png)]

# 字符串的查询操作
s = 'hello,hello'
print(s.index('lo'))  # 3
print(s.find('lo'))  # 3
print(s.rindex('lo'))  # 9
print(s.rfind('lo'))  # 9

# print(s.index('k'))# ValueError: substring not found
print(s.find('k'))  # -1
# print(s.rindex('k'))#ValueError: substring not found
print(s.rfind('k'))  # -1

字符串的大小写转换操作的方法

upper()

把字符串中所有字符都转成大写字母

lower()

把字符串中所有字符都转成小写字母

swapcase()

把字符串中所有大写字母转成小写字母，把所有小写字母都转成大写字母

capitalize()

把第一个字符转换成大写，把其余字符转换成小写

# 字符串中的大小写转换的方法
s = 'hello,python'
a = s.upper()  # 转成大写之后，会产生一个新的字符串对象
print(s)  # HELLO,PYTHON
print(a, id(a))  # HELLO,PYTHON 2190073744368
print(s, id(s))  # HELLO,PYTHON 1561669349040
print(s.lower())  # hello,python
print(s.lower(), id(s.lower()))  # hello,python 2207706857648
print(s, id(s))  # hello,python 2207706853296

s2 = 'hello,Python'
print(s2.swapcase())  # HELLO,pPYTHON

print(s2.title())  # Hello,Python

字符串内容对齐的方法

方法名称

center()

居中对齐，第一个参数指定宽度，第二个仓鼠指定填充符，第二个参数是可选的，默认是空格，如果设置款难度小于实际宽度则返回字符串

ljust()

左对齐，第1个参数指定宽度，第2个参数指定填充符，第二个参数是可选的，默认是空格如果设置宽度小于实际宽度则返回原字符串

rjust()

右对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则返回原字符串、

zfill()

右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的宽度，如果指定的款难度小于等于字符串的长度，返回字符串本身

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
print(s.rjust(10))  # hello,Python

'''右对齐,使用0进行填充'''
print(s.zfill(20))#00000000hello,Python
print(s.zfill(10))#hello,Python
print('-8910'.zfill(8))#-0008910

字符串的劈分

split()

从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表

s='hello world Python'
lst=s.split()
print(lst)#['hello', 'world', 'Python']

以通过参数sep指定劈分字符串是劈分符

通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大劈分之后，剩余的子串会单独做成一部分

s1='hello|world|Python'
print(s1.split(sep='|'))#['hello', 'world', 'Python']
print(s1.split(sep='|',maxsplit=1))#['hello', 'world|Python']

rsplit()

从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表

以通过参数sep指定劈分字符串是劈分符

通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串单独会做成一部分

s1 = 'hello|world|Python'
print(s1.split(sep='|'))  # ['hello', 'world', 'Python']
print(s1.split(sep='|', maxsplit=1))  # ['hello', 'world|Python']
s = 'hello world Python'
print(s.rsplit())  # ['hello', 'world', 'Python']
print(s.rsplit('|'))  # ['hello world Python']
print(s1.rsplit(sep='|', maxsplit=1))  # ['hello|world', 'Python']

字符串判断的相关方法

isidentifier()

判断指定的字符串是不是合法的标识符

isspace()

判断指定的字符串是否全部由空白字符组成(回车，换行，水平制表符)

isalpha()

判断指定的字符串是否全部由字母组成

isdecimal()

判断指定字符串是否全部由字母组成

isnumeric()

判断指定的字符串是否全部由数字组成

isalnum()

判断指定字符串是否全部由字母和数字组成

字符串操作的其他方法

字符串替换

replace()

第1个参数指定被替换的子串，第2个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可以通过第3个参数指定最大替换次数

字符串的合并

join()

将列表或元组中的字符串合并成一个字符串

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

lst = ['hello', 'java', 'Python']
print('|'.join(lst))  # hello|java|Python
print(''.join(lst))  # hellojavaPython

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

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

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

字符串的比较操作

运算符：>,>=,<,<=,==,!=

**比较规则：**首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，一次比较下去，指导两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较

**比较原理：**两个以上字符进行比较时，比较的是其ordinal value(原始值)，调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr，调用内置函数chr时指定ordinal value可以得到其对应的字符

a = b = 'Python'
c = 'Python'
print(a == b)  # True
print(b == c)  # True
print(a is b)  # True
print(a is c)  # True
print(id(a))  # 2592489649456
print(id(b))  # 2592489649456
print(id(c))  # 2592489649456

字符串的切片操作

print(s1)  # hello
print(s2)  # Python
print(newstr)  # hello!Python

print(s1)  # hello
print(s2)  # Python
print(newstr)  # hello!Python
print("-----------")
print(id(s))  # 2474006161840
print(id(s1))  # 2474010624176
print(id(s2))  # 2474010824176
print(id(s3))  # 2474010624048
print(id(newstr))  # 2474010639536

print("--------------切片[start:end:step]-----------------")
print(s[1:5:1])  # 从1开始截到5(不包含5),步长为1 ello
print(s[::2])  # 默认从0开始,没有写结束，默认字符串的最后一个元素，步长为2，两个元素之间的索引间隔为2 hloPto
print(s[::-1])  # 默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数 nohtyP,olleh
print(s[-6::1])  # 从索引为-6开始,到字符串的最后一个元素结束,步长为1 Python

格式化字符串

# (1)%占位符

name = '张三'
age = 20
print('我叫%s,今年%d岁' % (name, age))  # 我叫张三,今年20岁

# (2){}

print("我叫{0},今年{1}岁".format(name, age))  # 我叫张三,今年20岁

# {3}f-string

print(f'我叫{name},今年{age}岁')  # 我叫张三,今年20岁

print('%10d' % 99)#10表示的是宽度
print('%.3f' % 3.1415926)#.3表示是小数点后三位
#同时表示宽度和精度
print('%10.3f' % 3.1415926)#一共总宽度为10，小数点后3位

print('%10d' % 99)  #          99  10表示的是宽度
print('%.3f' % 3.1415926)#3.142
#同时表示宽度和精度
print('%10.3f' % 3.1415926)#     3.142 一共总宽度为10，小数点后3位

print('hellohello')  # hellohello
print('hellohello')

print('{0:.3f}'.format(3.1415926))#.3表示的是一共是3位数
print('{0:.3f}'.format(3.1415926))#.3f表示是3位小数
print('{:10.3f}'.format(3.1415926))#同时设置宽度和精度

字符串的编码与解码

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'))  # 解码

byte = s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))

函数

函数调用的参数传递 _ 位置实参 _ 关键字实参

# 位置实参
# 根据形参对应的位置进行实参传递
def calc(a, b):
    c = a + b
    return c


result = calc(10, 20)
print(result)

# 关键字实参
# 根据形参名称进行实参传递
res = calc(b=10, a=20)  # 等号左侧的变量的名称成为关键字参数
print(res)

函数的返回值

print(bool(0))  # False
print(bool(8))  # 非0的布尔值为True


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

'''函数的返回值
(1)如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】return可以省略不写
(2)函数的返回值,如果是1个,直接返回类型
(3)函数的返回值，如果是多个，返回的结果为元组
'''


def fun1():
    print('hello')
    # return脱了裤子放屁


fun1()


def fun2():
    return 'hello'


res = fun2()
print(res)


def fun3():
    return 'hello', 'world'


print(fun3())

'''False
True
([29, 23, 53, 55], [10, 34, 44])
hello
hello
('hello', 'world')
'''

函数参数定义_默认值参数

def fun(a, b=10):
    print(a, b)


# 函数的调用
fun(100)  # 100 10
fun(20, 30)  # 20 30

print('hello',end='\t')
print('world')#hello	world

函数的参数定义

个数可变的位置参数

定义函数，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数

使用*定义个数可变的位置形参

结果为一个元组

个数可变的关键字形参

定义函数时，无法实现确定传递的关键字实参的个数时，使用可变的关键字形参

使用**定义个数可变的关键字形参

结果为一个字典

函数参数定义 _ 个数可变的位置形参 _ 个数可变的关键字形参

def fun(*args):  # 函数定义时的可变的位置参数
    # 为什么可变,因为传多少都可以
    print(args)
    print(args[0])


fun(10)
fun(10, 30)
fun(30, 405, 50)


def fun1(**args):
    print(args)


fun1(a=10)
fun1(a=20, b=30, c=40)

print('hello', 'world', 'java')

'''def fun2(*args,*a):
   pass
   以上代码,程序会报错，个数可变的位置参数，只能是1个
   def fun2(**args,**args):
    pass
    以上代码,程序会报错，个数可变的位置参数，只能是1个
   '''


def fun2(*args1, **args2):
    pass


'''def fun2(**args,**args):
    pass
    在一个函数的定义过程中，既有个数可变的关键字,也有个数可变的位置形参,要求,个数可变的位置形参,放在个数可变的关键字形参之前
'''

函数的参数总结

def fun(a, b, c):  # a,b,c在函数的定义处,所以是形式参数
    print('a=', a)
    print('b=', b)
    print('c=', c)


# 函数的调用
fun(10, 20, 30)  # 函数调用时的参数传递,称为位置传参
lst = [11, 22, 33]
fun(*lst)
print('----------------')
fun(a=100, c=300, b=200)  # 函数的调用,所以是关键字实参
dic = {'a': 111, 'b': 222, 'c': 333}
fun(**dic)  # 在函数调用时,将字典中的键值对都转换为关键字实参传入
'''
a= 10
b= 20
c= 30
a= 11
b= 22
c= 33
----------------
a= 100
b= 200
c= 300
a= 111
b= 222
c= 333
'''

def fun(a, b=10):  # b是在函数的定义处,所以b是形参,而且进行了赋值,所以b称为默认值形参
    print('a=', a)
    print('b=', b)


def fun2(*args):  # 个数可变的位置形参
    print(args)


def fun3(**args2):  # 个数可变的关键字形参
    print(args2)


fun2(10, 20, 30, 40)  # (10, 20, 30, 40)
fun3(a=11, b=22, c=33, d=44, e=55)


def fun4(a, b, *, c, d):  # 从*之后的参数,在函数调用时,只能采用关键字参数传递
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)


# 调用fun4函数
fun4(10, 20, 30, 40)  # 位置实参传递
fun4(a=10, b=20, c=30, d=40)  # 关键字实参传递
fun4(10, 20, c=30, d=40)  # 前两个参数，采用的是位置实参传递,而c,d采用的是关键字实参传递

'''需求,  c,d只能采用关键字实参传递'''

'''函数定义时的形参的顺序问题'''


def fun5(a, b, *, c, d, **args):
    pass


def fun6(*args, **args2):
    pass


def fun7(a, b=10, *args, **args2):
    pass

变量的作用域

变量的作用域

def fun(a, b):
    c = a + b  # c,就是全局变量,因为c在函数体内进行定义的变量,a,b为函数的形参,作用范围也是函数内部,相当于局部变量
    print(c)


# print(c),因为a、c超出了起作用的范围(超出了作用域)
# print(a)

name = '杨老师'#name的作用范围为函数内部和外部都可以使用-->成为全局变量
print(name)


def fun2():
    print(name)

#调用函数
fun2()

def fun3():
    global age #函数内部定义的变量,局部变量,局部变量使用global声明,这个变量实际上就变成了全局变量
    age=20
    print(age)
fun3()
print(age)

# 调用函数
fun2()

'''杨老师
杨老师
20
20
杨老师
'''

递归函数

什么是递归函数

如果在一个函数体内调用了该函数本身，这个函数就称为递归函数

递归的组成部分

递归调用与递归终止条件

递归的调用过程

每递归调用一次函数，都会在栈内存分配一个栈帧

每执行完一次函数，都会释放相应的空间

递归的优缺点

缺点：占用内存多，效率低下

优点：思路和代码简单

def fac(n):
    if n == 1:
        return 1
    else:
        res = n * fac(n - 1)
        return res


print(fac(6))#720

斐波那契数列

def fib(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fib(n - 1) * fib(n - 2)


# 斐波那契数列第六位上的数字
print(fib(6))

# 输出这个数列的前6位上的数字
for i in range(1, 7):
    print(fib(i))
    
'''def fib(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fib(n - 1) * fib(n - 2)


# 斐波那契数列第六位上的数字
print(fib(6))

# 输出这个数列的前6位上的数字
for i in range(1, 7):
    print(fib(i))'''

Bug

Bug的常见类型

age = input('请输入你的年龄')
print(type(age))
if int(age) >= 18:
    print('成年人...')

1、漏了末尾的冒号，如if语句，循环语句，else子句等

2、缩进错误，该缩进的没缩进，不该缩进的瞎缩进

3、把英文符号写成中文符号，比如说：引号，冒号，括号

4、字符串拼接的时候，把字符串和数字拼在一起

5、没有定义变量，比如说while的循环条件的变量

6、“==”比较运算符合“=”赋值运算符的混用

知识不熟练导致的错误

（1）索引越界问题IndexError

lst=[11，22，33，44]

print(lst[4])

lst = [11, 22, 33, 44]

print(lst[3])

(2)append()方法的使用掌握不熟练

lst=[]

lst=append(‘A’,‘B’,‘C’)

print(lst)

lst=[]
lst.append('A')
lst.append('B')
lst.append('C')
print(lst)#['A', 'B', 'C']

思路不清晰导致

lst = [{'rating': [9.7], 'id': '1292052', 'type': ['犯罪'], 'title': '肖申克的救赎',
        'actors': ['蒂姆', '摩根']},
       {'rating': [9.6], 'id': '1291546', 'type': ['剧情'], 'title': '霸王别姬',
        'actors': ['张国荣', '张丰毅']},
       {'rating': [9.5], 'id': '1292720', 'type': ['剧情'], 'title': '阿甘正传',
        'actors': ['汤姆', '罗宾']}]

name = input('请输入您要查询的演员：')
for item in lst:  # 遍历列表 -->{} item是一个又一个的字典
    act_lst = item['actors']
    for actor in act_lst:  # 遍历字典,得到movie是一个字典中的key
        if name in actor:
            print(name, '出演了', item['title'])

'''actors = movie['actors']
   if name in actors:
   print(name + '出演了：' + movie)
'''

被动掉坑

被动掉坑：程序代码逻辑没有错，知识因为用户错误操作或者一些“例外情况”而导致的程序崩溃

**题目要求：**输入两个整数并进行除法运算

try:
    a = int(input('请输入第一个整数'))
    b = int(input('请输入第二个整数'))
    result = a / b
    print('结果为：', result)
except ZeroDivisionError:
    print('对不起,除数不允许为0')
except ValueError:
    print('只能输入数字串')
print('程序结束')

try-except-else结构

try:
    a = int(input('请输入第一个整数'))
    b = int(input('请输入第二个整数'))
    result = a / b
except BaseException as e:
    print('出错了', e)
else:
    print("计算结果为：",result)

try:    a = int(input('请输入第一个整数'))    
        b = int(input('请输入第二个整数'))    
        result = a / bexcept BaseException as e:    
        print('出错了', e)
else:    print("计算结果为：",result)
finally:    print('谢谢您的使用')python

Python中常见的异常类型

ZeroDivisionError除零

IndexError序列中没有此索引

KeyError映射中没有这个键

NameError未声明/初始化对象（没有属性）

SyntaxErrorPython语法错误

ValueError传入无效的参数

# print(10/0)#ZeroDivisionError
lst = [11, 22, 33, 44]
#print(lst[4])  # IndexError
#print(num)#NameError
#int a=20#SyntaxError
a=int('hello')#ValueError

traceback模块的使用

import traceback

try:
    print('-------------------------')
    print(1 / 0)
except:
    traceback.print_exc()

面向对象

类

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进行修饰,所以我是静态方法')

    # 类方法
    def cm(cls):
        print('我是类方法,因为我使用了classmethod进行修饰')


# 在类之外定义的成为函数，在类之内定义的成为方法
def drink():
    print('喝水')

类属性、类方法、静态方法的使用

**类属性：**类中方法外的变量成为类属性，被该类的所有对象多共享

类方法：使用@classmethod修饰的方法，使用类名直接访问的方法

静态方法：使用@staticmethod修饰的主法，使用类名直接访问的方法

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进行修饰,所以我是静态方法')

    # 类方法
    def cm(cls):
        print('我是类方法,因为我使用了classmethod进行修饰')


# 在类之外定义的成为函数，在类之内定义的成为方法
def drink():
    print('喝水')


# 类属性的使用方式
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()
print('----------------静态方法的使用方式---------------')
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('李四', 30)
print(id(stu1))
print(id(stu2))
stu2.gender = '女'  # 只为stu2动态绑定了性别
print(stu1.name, stu1.age)
print(stu2.name, stu2.age, stu2.gender)

stu1.eat()
stu2.eat()

#动态绑定方法
def show():
    print('定义在类之外的,称函数')

stu1.show=show
stu1.show()
#stu2.show()

'''1997157314512
1997157313120
张三 20
李四 30 女
张三在吃饭
李四在吃饭
定义在类之外的,称函数
'''

面向对象的三大特征_封装的实现方式

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()
#在类的外面使用name与age时
print(stu.name)
#print(stu.__age)
print(dir(stu))
print(stu._Student__age)#在类的外部可以通过 _Student__age 进行访问

继承及其实现方式

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


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


stu = Student('张三', 20, '1001')
teacher = Teacher('李四', 34, 10)

stu.info()
teacher.info()
'''
张三 20
李四 34'''
# 多继承
class A(object):
    pass


class B(object):
    pass


class C(A, B):
    pass

方法重写

方法重写

·如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其（方法体）进行重新编写

·子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法

Object类

·object类是所有类的父类，因此所有类都有object类的属性和方法。

·内置函数dir()可以查看指定对象所有属性

·Object有一个__str__()方法，用于返回一个’对象的描述’，对应与内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对__str__()进行重写

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return '我的名字是{0},今年{1}岁'.format(self.name, self.age)


stu = Student('张三', 20)
print(dir(stu))
print(stu)  # 默认调用__str__()这样的方法
print(type(stu))

'''['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']
我的名字是张三,今年20岁
<class '__main__.Student'>'''

多态的实现

多态就是"具有多种形态"，它指的是：几遍不知道一个变量所引用的对象到底是什么类型，任然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法

静态语言和动态语言关于多态的区别

·静态语言实现多态的三个必要条件

·继承

·方法重写

·父类引用指向子类对象

·动态语言的多态崇尚“鸭子类型”当看到一只鸟走起来想鸭子、游泳起来像鸭字、收起来也想鸭子，name这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为

特殊属性

class A:
    pass


class B:
    pass


class C(A, B):
    def __init__(self, name, age):
        self.name = name
        self.age = age


# 创建C类的对象
x = C('Jack', 20)  # x是C类型的一个实例对象
print(x.__dict__) #实例对象的属性字典
print(C.__dict__)
print(x.__class__)#输出了对象所属的类
print(C.__bases__)#C类的父类类型的元素
print(C.__base__)
print(A.__subclasses__())

'''
{'name': 'Jack', 'age': 20}
{'__module__': '__main__', '__init__': <function C.__init__ at 0x0000024C5F89DB80>, '__doc__': None}
<class '__main__.C'>
(<class '__main__.A'>, <class '__main__.B'>)
<class '__main__.A'>
'''

特殊方法

a = 20
b = 100
c = a + b  # 两个帧数类型的对象的相加操作
d = a.__add__(b)

print(c)
print(d)


class Student:
    def __init__(self, name):
        self.name = name

    def __add__(self, other):
        return self.name + other.name

    def __len__(self):
        return len(self.name)


stu1 = Student('张三')
stu2 = Student('李四')
s = stu1 + stu2  # 实现了两个对象的加法运算(因为在Student类中,编写__add__()特殊的方法)
print(s)
s = stu1.__add__(stu2)
print(s)
lst = [11, 22, 33, 44]
print(len(lst))  # len是内置函数len,可以计算列表的长度
print(lst.__len__())
print(len(stu1))

'''特殊属性 
__dict__
获得类对象或实例对象所绑定的所有属性和方法的字典

特殊方法
__len__()
通过重写__len__()方法,让内置函数len()的参数可以自定义类型
__add__()
通过重写__add__()方法,可使用自定义对象具有“+”功能
__new__()
用于创建对象
__init__()
对创建的对象进行初始化

'''

__new__与__init__演示创建对象的过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dr1fcSnZ-1643201540467)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220124114008841.png)]

class Person(object):

    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('p1这个Person类的实例对象的id:{0}'.format(id(p1)))

类的赋值与浅拷贝

变量的赋值操作

只是形成两个变量，实际上还是只想同一个对象

浅拷贝

Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象

深拷贝

使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同

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(cpu1)
print(cpu2)

# (2)类有浅拷贝
print('------------------------------')
disk = Disk()  # 创建一个硬盘类对象
computer = Computer(cpu1, disk)  # 创建一个计算机类的对象

# 浅拷贝
import copy

print(disk)
computer2 = copy.copy(computer)
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.cpu, computer3.disk)



<__main__.CPU object at 0x0000023E0FC21FD0>
<__main__.CPU object at 0x0000023E0FC21FD0>
------------------------------
<__main__.Computer object at 0x0000023E0FC21F70> <__main__.CPU object at 0x0000023E0FC21FD0> <__main__.Disk object at 0x0000023E0FC21FA0>
<__main__.Computer object at 0x0000023E0FC21190> <__main__.CPU object at 0x0000023E0FC21FD0> <__main__.Disk object at 0x0000023E0FC21FA0>

模块

创建模块

新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同

导入模块

import 模块名称 [as 别名]

from 模块名称 import 函数/变量/类

import math  # 关于数学运算

print(id(math))
print(type(math))
print(math)
print(math.pi)
print('----------------------')
print(dir(math))
print(math.pow(2, 3), type(math.pow(2, 3)))
print(math.ceil(9.001))
print(math.floor(9.999))

'''
2855299925232
<class 'module'>
<module 'math' (built-in)>
3.141592653589793
----------------------
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
8.0 <class 'float'>
10
9'''

from math import pi

print(pi)
print(pow(2, 3))
# print(math.pow(2,8))

模块的导入

def add(a, b):
    return a + b


def div(a, b):
    return a / b

# 这个模块的名称是calc



import calc
print(calc.add(10,20))
print(calc.div(10,4))


from calc import add
print(add(10,20))

以主程序方式运行124

def add(a, b):
    return a + b


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

Python中的包

sys 与Python解释其及其环境操作相关的标准库

time提供与时间相关的各种函数的标准库

os提供了访问操作系统服务功能的标准库

calendar提供与日期相关的各种函数的标准库

urllib用于读取来自网上（服务器）的数据标准库

json用于使用Json序列化和反序列化对象

re用于在字符串中执行正则表达式匹配和替换

math提供标准算数运算函数的标准库

decimal用于进行精准控制运算精度、有效数位和四舍五入操作的十进制运算

logging提供了灵活的记录时间、错误、警告和调试信息的功能

import sys
import time
import urllib.request

print(sys.getsizeof(24))#28
print(sys.getsizeof(45))#28
print(sys.getsizeof(True))#28
print(sys.getsizeof(False))#24
print(time.time())#1643016733.717006
print(time.localtime(time.time()))#time.struct_time(tm_year=2022, tm_mon=1, tm_mday=24, tm_hour=17, tm_min=32, tm_sec=13, tm_wday=0, tm_yday=24, tm_isdst=0)

print(urllib.request.urlopen('http://www.baidu.com').read())

第三方模块的安装126

文件

编码格式的介绍

常见的字符编码格式

Python的解释器使用的是Unicode(内存)

py文件在磁盘上使用UTF-8存储（外存）

文件读写的原理_读取磁盘文件中的内容

·文件的读写俗称“IO操作”

·文件读写操作流程

·操作原理

file = open('a.txt', 'r')
print(file.readlines())
file.close()

常用的文件打开模式131

文件类型

按文件中数据的组织形式，文件分为以下两大类

**文本文件：**存储的是普通"字符"文本，默认为uincode字符集，可以使用记本事程序打开

**二进制文件：**把数据内容用“字节”进行存储，无法用记事本打开，必须使用专用的软件打开，举例：mp3音频文件，jpg图片，.doc文档等

r以值读模式打开文件，文件的指针将会放在文件的开头

w以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，文件指针在文件的开头

a以追加模式打开文件，如果我呢间不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾住家内容，文件指针在源文件末尾

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

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

#w
file = open('b.txt', 'w')
file.write('Python')
file.close()
#b
src_file = open('b.txt', 'r')

target_file = open('copylogo.png', 'wb')

print(target_file.write(src_file.read()))

target_file.close()
src_file.close()

**read([size])**从文件中读取size个字节或字符的内容返回。若省略[size]，则读取到文件末尾，即一次读取文件所有内容

**readline()**从文本文件中读取一行内容

**readlines()**把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回

**write（str）**将字符串str内容写入文件

**writelines（s_list）**将字符串str内容写入文件

**writelines(s_list)**将字符串列表s_list写入文本文件，不添加换行符

seek把文件指针移动到新的位置，offset表示相对于whence的位置：offset：为正往结束方向移动，为负往开始方向移动 whence不同的值代表不同含义

0：从文件头开始计算默认值（默认值）

1：从当前位置开始计算

2：从文件末开始计算

**tell()**返回文件指针的当前位置

**flush()**把缓冲区的内容写入文件，但不关闭文件

**close()**把缓冲区的内容写入文件，同时关闭文件，释放对象相关资源

file = open('c.txt', 'a')
lst = ['java', 'go', 'python']
file.writelines(lst)
file.close()

#javagopython

file = open('a.txt', 'r')
file.seek(2)
print(file.read())
print(file.tell())
file.close()

with语句（上下文管理器）

·with语句可以自动管理上下文资源，不论什么原因跳出with都能确保文件正确的关闭，以此来大道释放资源的目的

class MyContentMgr(object):
    def __enter__(self):
        print('enter方法被调用执行了')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("exit方法被调用执行了")

    def show(self):
        print('show()方法被调用执行了')


with MyContentMgr() as file:
    file.show()
    
#另一个文件
with open('a.txt', 'r') as file:
    print(file.read())

'''改进
with open('logo.png','rb') as src_file:
    with open('copy2logo.png','wb') as target_file:
        target_file.write(src_file.read())
'''

os模块的常用函数

import os
os.system('notepad.exe')
os.system('calc.exe')
#直接调用
os.startfile('C:\\Program Files (x86)\\Tencent\\TIM\\Bin\\tim.exe')

os模块是Python内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样。

os模块与os.path模块用于对目录或文件进行操作

import os
os.system('notepad.exe')
os.system('calc.exe')
#直接调用
os.startfile('C:\\Program Files (x86)\\Tencent\\TIM\\Bin\\tim.exe')

import os
print(os.getcwd())

**getcwd（）**返回当前的工作目录

**listdir(path)**返回指定路径下的文件和目录信息

**mkdir(path[,mode])**创建目录

**makedirs(path1/path2)**创建多级目录

**rmdir(path)**删除目录

**removedirs(path1/path2)**删除多级目录

**chdir(path)**将path设置为当前工作目录

import os
print(os.getcwd())

lst = os.listdir('../chap15')
print(lst)

os.mkdir('newdir2')
#os.makedirs('A/B/C/')

os.rmdir('newdir2')
os.removedirs('A/B/C')

os.path模块的常用方法

path模块操作目录相关函数

**abspath(path)**用于获取文件或目录的绝对路径

**exists(path)**用于判断文件或目录是否存在，如果存在返回True，否则返回False

**join(path，name)**将目录与目录或者文件名拼接起来

**splitext()**将目录与目录或者文件名拼接起来

**basename(path)**从一个目录中提取文件名

**dirname(path)**从一个路径中提取文件路径，不包括文件名

**isdir(path)**用于判断是否为路径

import os.path

print(os.path.abspath('demo10.py'))
print(os.path.exists('demo13py'), os.path.exists('demo10.py'))

剩下的听不懂

实操案例

实操案例一

任务1：向文件输出’奋斗成就更好的你’

"""一、使用print方式进行输出(输出的目的地是文件)"""
fp = open('C:/李林峰/text.txt', 'w')#open是打开创建文件的意思
print('奋斗成就更好的未来',file=fp)
fp.close()
'''二、使用文件的读写操作'''
with open('C:/李林峰/text2.txt', 'w') as file:
    file.write('奋斗成就更好的未来')

实操案例二

输出《红楼梦中的金陵十二钗》前5位

'''1  变量的赋值'''
name1='林黛玉'
name2='薛宝钗'
name3='贾元春'
name4='贾探春'
name5='史湘云'
print('1\t'+name1)
print('2\t'+name2)
print('3\t'+name3)
print('4\t'+name4)
print('5\t'+name5)
'''2种方式 列表'''
lst_name=['林黛玉','薛宝钗','贾元春','贾探春','史湘云']
lst_sig=['1','2','3','4','5']
for i in range(5):
    print(lst_sig[i],'\t',lst_name[i])
'''3种方式 字典'''
d={'1':'林黛玉','2':'薛宝钗','3':'贾元春','4':'贾探春','5':'史湘云'}
for key in d:
    print(key,d[key])
print('zip-----------')
for s,name in zip(lst_sig,lst_name):
    print(s,name)

图像音像勋章

print('\033[0:35m\t\t图像音像勋章\033[m')
print('\033[0:35m---------------------\033[m')

输出你的身体指标

height=170
weight=50.5
bmi=weight/(height+weight)
print('您的身高是:'+str(height))
print('您的体重是:'+str(weight))
print('您的BMI的指数是:'+'{:0.2f}'.format(bmi))

实操案例三

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R1zpsXrZ-1643201540468)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220125104315944.png)]

将指定的十进制数转换成二进制、八进制、十六进制

二进制 ------>binary system

八进制 ------>octonary number system 英 /ˈɒktənəri/

十进制 ------>decimalism 英 /ˈdesɪməlɪzəm/

def fun():

   num=int(input('请输入一个十进制的整数'))#将str转换成int类型
   print(num,'的二进制数是:',bin(num))#第一种写法,使用了个数可变的位置参数
   print(str(num)+'的二进制数为：'+bin(num))#第二种写法,使用“+”作为连接符(+的左右均为str类型)
   print('%s的二进制位:%s'%(num,bin(num)))#第三种写法,格式化字符串
   print('{0}的二进制数为：{1}'.format(num,bin(num)))#第三种写法,格式化字符串
   print(f'{num}的二进制数为:'{bin(num)})#第三种方式,格式化字符串
   print(f'{num}的八进制数为:'{oct(num)})
   print(f'{num}的十六进制数为:'{hex(num)})

if __name__ == '__main__':
     while True:
         try:
             fun()
             break#如果程序正常输出结束以后,我们再break
         except:
             print('只能输入整数！程序出错,请重新输入')

为自己手机充值

print('用户手机账户原有话费金额为:\033[0:35m8元\033[m')
money=int(input('请输入用户充值金额:'))
money+=8
print('当前的金额为:\033[0:35m',money,'元\033[m')
'''
用户手机账户原有话费金额为:8元
请输入用户充值金额:100
当前的金额为: 108 元
'''

计算能量的消耗

num=int(input('请输入您当天行走的步数:'))
calorie=num*28
print(f'今天共消耗了卡路里{calorie},即{calorie/1000}千卡')

'''
请输入您当天行走的步数:10000
今天共消耗了卡路里280000,即280.0千卡
'''

预测未来子女的身高

father_height=float(input('请输入父亲的身高:'))
mother_height=float(input('请输入母亲的身高:'))
son_height=(father_height+mother_height)*0.54
print('预测子女的身高为:{}cm'.format(son_height))

'''
请输入父亲的身高:170
请输入母亲的身高:168
预测子女的身高为:182.52cm'''

实操案例四

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NaiTxVnV-1643201540468)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220125114055615.png)]

支付密码的验证

pwd=input('支付宝支付密码:')
if pwd.isdigit():
    print('支付数据合法')
else:
    print('支付数字不合法,支付密码只能是数据')

print('-------------------------------------------')
print('支付数据合法' if pwd.isdigit() else '支付数字不合法,支付密码只能是数据')

模拟QQ账号登录

qq=input('请输入qq号:')
pwd=input('请输入密码:')
if qq=='1059630434' and pwd=='123':
    print('登陆成功')
else:
    print('对不起,账号或密码不正确')

商品价格大竞猜

import random
price=random.randint(1000,1500)
print('今日竞猜的商品为小米草地机器人:价格在[1000-1500]之间:')
guess=int(input())
if guess>price:
    print('大了')
elif guess<price:
    print('小了')
else:
    print('猜对了')
print('真实价格为:',price)

根据星座查看运势

d={
    '白羊座':'''1''',
    '金牛座':'''2'''
}
star=input('请输入您的星座查看近来运势:')
print(d.get(star))

'''请输入您的星座查看近来运势:白羊座
1'''

实操案例五

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bqgG9JCd-1643201540474)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220125121002601.png)]

循环输出26个字母对应的ASCll码值

x=97#代表的是a的ASCII值
for _ in range(1,27):
    print(chr(x),'--->',x)
    x+=1

print('-----------')
x=97
while x<123:
    print(chr(x),'-->',x)
    x+=1

模拟用户登录

for i in range(1,4):
    user_name=input('请输入用户名:')
    user_pwd=input('请输入密码:')
    if user_name=='admin' and user_pwd=='8888':
        print('登录成功')
        break
    else:
        print('用户名或密码不正确!!!')
        if i<3:
            print(f'您还有{3-i}次机会！！！')
else:#这个else的意思是当你的这三个循环都结束后就会执行这个else之后的语句
    print('对不起,三次均输入错误,请联系后台管理员')

猜数游戏

import random
rand=random.randint(1,100)
for i in range(1,11):
    num=int(input('在我心中有个数1-100,请你猜一猜'))
    if num<rand:
        print('小了')
    elif num>rand:
        print('大了')
    else:
        print('恭喜你猜对了')
        break
print(f'您一共猜了{i}次')
if i<3:
    print('真聪明')
elif i<=7:
    print('还凑合')
else:
    print('天哪,找杨老师学习折半算法！！！')

计算100-999之间的水仙花数

import math
for i in range(100,1000):
    if math.pow((i%10),3)+math.pow((i//10%10),3)+math.pow(i//100,3)==i:
        print(i)

实操案例六

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oFUhxFn2-1643201540474)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220126195422389.png)]

千年虫我来了

year=[82,89,88,86,85,00,99]
print('原列表',year)
for index,value, in enumerate(year):
    #print(index,value)
    if str(value)!='0':
        year[index]=int('19'+str(value))

    else:
        year[index]=int('200'+str(value))

print('修改之后的列表:',year)
#列表的排序
year.sort()
print('排序之后的列表为:',year)

京东购物流程

lst=[]
for i in range(0,5):
    goods=input('请输入商品编号和商品名称进入商品的入库,每次只能输入一件商品:\n')
    lst.append(goods)
for item in lst:
    print(item)

cart=[]
while True:
    num=input('请输入要购买的商品编号:')
    for item in lst:
        if item.find(num)!=-1:
            cart.append(item)
            break# 退出for
    if num=='q':
        break #退出while循环
print('您购物车里已经选好的商品为:')
for i in range(len(cart)-1,-1,-1):
    print(cart[i])

实操案例七

根据星座测试性格特点

key=input('请输入您的星座名称')
flag=True
for item in d:
    if key==item:
        flag=True
        print(key,'的性格特点为:',d.get(key))
        break
    else:
        flag=False
if not flag:
    print('对不起,您输入的星座有误')

模拟12306货车票订票下单

dict_ticket={'G120':['天津-上海','18:05'],
             'G153':['北京-天津','18:15']}
print('车次\t\t出发站-到达站\t\t')
for item in dict_ticket:
    print(item,end=' ')
    for i in dict_ticket[item]:
        print(i,end='     ')
    print()#换行
#请输入要购买的车次
train_no=input('请输入要购买的车次:')
persons=input('请输入乘车人，如果是多人请使用逗号分隔')
s=f'您已购买了{train_no}次列表'
s_info=dict_ticket[train_no]#获取车次详细信息
s+=s_info[0]+' '+s_info[1]+' 开'
print(f'{s}请{persons}尽快取走纸质车票.')

实操案例八

我的咖啡馆你做主

print('本店经营的咖啡有:')
for index,item in enumerate(coffee_name):
    print(index+1,',',item,end='   ')

index=int(input('\n请输入您喜欢的咖啡编号:'))
if 0<=index<=len(coffee_name):
    print(f'您的咖啡[{coffee_name[index-1]}]好了,请您慢用')

Python print输出带颜色 总结

https://mp.weixin.qq.com/s?src=11&timestamp=1643077913&ver=3579&signature=Xs5i8fOba3Gvnk6VoReCQEZbFoRsxdHCv78bIkAR83AXabyIBVQXrSpTxpM7XqJrsF1K9JCf8l4erybJS7kfqksl2v6e0J2*SbQzGq-ZSelf-ULL9K3d7u970gXII3nP&new=1

# 最最基本

## print函数

### 将数据输出文件中

```python
#将数据输出文件中,注意点，1.所指定的盘符存在。2.使用file=fp

fp = open('C:/李林峰/text.txt', 'a+')#如果文件不存在就创建，存在就在文件内容后面继续追加
print('helloworld', file=fp)
fp.close()

#不进行换行输出（输出内容在一行当中）

print（'hello','world','Python')

open的方式是输出到文件当中

print的方式是输出到显示器当中+

不进行换行输出（输出的内容在一行中）

print('hello','world','Python')

常用的转义字符

print('hello\nworld')  # 换行  n->newline
print('hello\tworld')  # 空了三隔
print('helloooo\tworld')  # 空了四隔->tab键
print('hello\rworld')  # world将hello进行了覆盖->return光标移动到本行的开头
print('hello\bworld')  # \是退格back

print('http:\\\\www.bandu.com')
print('老师说：\'大家好\'')

#原字符，不希望字符串中的转义字符起作用，就是用元字串之前加上r或R
print(r'hello\nworld')
#注意事项，最后一个字符不能是反斜杠，可以是两个反斜杠
print(r'hello\nworld\\')

变量的定义和使用

name = '玛利亚'
print(name)
print('标识', id(name))
print('类型', type(name))
print('值', name)

数据类型

·常见的数据类型

·整数类型->int->98

·浮点数类型->float->3.14159

·布尔类型->bool->True,False

·字符串类型->str->人生苦短

整数类型

#整数可以表示二进制，十进制，八进制，十六进制
print('十进制'，118)#默认十进制
print('二进制'，0b1010111)#二进制以0b开头
print('八进制'，0o176)#八进制以0o开头
print('十六进制'，0x1EAF)

浮点类型

n1 = 1.1
n2 = 2.2
print(n1+n2)#3.3000000000000003

from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))#3.3

布尔类型

f1 = True
f2 = False
print(f1,type(f1))#True <class 'bool'>
print(f2,type(f2))#False <class 'bool'>

#布尔值可以转成整数计算
print(f1+1) #2     1+1的结果为2，True表示1
print(f2+1) #1     0+1的结果为2，False表示0

字符串类型

str1 = '人生苦短，我用python'
str2 = "人生苦短，我用python"
str3 = """人生苦短，
我用python"""
str4 = ‘‘‘人生苦短，
我用python’’’
#单引号和双引号定义的字符串必须在一行
print(str1,type(str1))#人生苦短，我用python<class 'str'>
print(str2,type(str2))
#三引号定义的字符串可以分布在连续的多行
print(str3,type(str3))
print(str4,type(str4))

类型转换_str()函数与int()函数

str()函数

name = '张三'
age = 20

print(type(name),type(age))#说明name与age的数据类型不相同
print('我叫'+name+'今年'+age+'岁')#当将str类型与int类型进行链接时，报错，解决方案，类型转换
print('我叫'+name+'今年'+str(age)+'岁')

int()函数

s1 = 128
f1 = 98.7
s2 = '76.77'
ff = True
s3 = 'hello'
print(type(s1), type(f1), type(s2), type(ff), type(s3))
print(int(s1), type(int(s1)))  #将str转成int类型，字符串为数字串
print(int(f1), type(int(f1)))  #float转成int类型，截取整数部分，舍掉小数部分
# print(int(s2), type(int(s2)))  #将str转成int类型，报错，因为字符串为小数串
print(int(ff), type(int(ff)))
#print(int(s3), type(int(s3)))  #将str转成int类型，字符串必须为数字串（整数），非数字串是不允许转换的

float类型转换

#字符串中的数据如果是非数字串，则不允许转换

Python中的注释

#单行注释

"""我是多行注释
"""

Input函数的使用

present = input('大圣想要什么礼物呢')#输入之前程序给你的一个提示语   需要输入回答

input函数的高级使用

a = input('请输入一个加数：')#10
b = input('请输入另一个加数：')#10
print(type(a), type(b))#<class 'str'><class 'str'>
print(a + b)#1020


a = input('请输入一个加数：')#10
b = input('请输入另一个加数：')#10
print(type(a), type(b))#<class 'str'><class 'str'>
print(int(a) + int(b))#30

或者a = int(input('请输入一个加数：'))

运算符

算数运算符

print(1+1)# 加法运算
print(1-1) # 减法运算
print(2*4)# 8 乘法运算
print(1/2)# 除法运算
print(11/2)#5.5 除法运算
print(11//2)# 5 整除运算
print(11%2)# 1 取余运算
print(2**2)# 4 表示的是2的2次方
print(2**3)# 8 表示的是2的3次方

含减号的运算

print(9 // 4)  # 2
print(-9 // -4)  # 2

print(9 // -4)  # -3
print(-9 // 4)  # -3 一正一负的整数公式，向下取整

print(9 % -4)  # -3 余数=被除数-除数*商 9-(-4)*(-3)
print(-9 % 4)  # 3

赋值运算符

#解包赋值
a,b,c=20,30,40
print(a,b,c)
print('-----------交换两个变量的值----------')
a,b=10,20
print('交换之前：',a,b)#交换之前：10 20
#交换
a,b=b,a
print('交换之后:',a,b)#交换之后：20 10

比较运算符

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)#True 说明，a与b的value相等
print(a is b)#True 说明， a与b的id标识相等

#以下代码没学过，后面会给大家讲解
llist1=[11,22,33,44]
llist2=[11,22,33,44]
print(lstr1==lstr2)#value -->True
print(lstr1 is lstr2)#id -->False
print(id(lstr1))#267587787
print(id(lstr2))#787897988
print(lstr1 is not lstr2) #True

布尔运算

#and并且
#or或者
#not 对bool类型操作数取反
f=True
f2=False
print(not f)#False
print(not f2)#True
#in与not in
s = 'helloworld'
print('w' in s)#True
print('k' in s)#False
print('w' not in s)#False
print('k' not in s)#True

位运算

print(4 & 8)  # 0 按位于&,同为1时结果为1
print(4 | 8)  # 12 按位或|，同为0时结果为0
print(4 << 1)  # 8 向左移动1位(移动一个位置)相当于乘以2
print(4 << 2)  # 16 向左移动2位(移动2个位置)

print(4 >> 1)  # 2 向右移动1位，相当于除以2
print(4 >> 2)  # 1 向右移动2位，相当于除以4

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9Mx3a8gp-1643201542068)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220119175339789.png)]

运算符的优先级

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rY2tN5rZ-1643201542069)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220119180200590.png)]

对象的布尔值

print(bool(False))#False
print(bool(0))#False
print(bool(0.0))#False
print(bool(None))#False
print(bool(''))#False
print(bool(""))#False
print(bool([]))#False空列表
print(bool(list()))#False空列表
print(bool(()))#False空元组
print(bool(tuple))#False空元组
print(bool({}))#空字典
print(bool(dict()))#False空字典
print(bool(set()))#False空集合

其他的bool值为True
print(bool(18))#True
print(bool('helloworld'))#True

选择结构

单分支结构

money = 1000
s = int((input('请输入取款金额')))#取款金额
#判断金额是否充足
if money>=s:
    money=money-s
    print('取款成功，金额为：',money)

双分支结构

num = int(input('请输入一个整数'))
#条件判断
if num%2==0:
    print(num,'是偶数')
else：
    print(num,'是奇数')

多分支结构

score = int(input('请输入一个成绩：'))
# 判断
if 90 <= score <= 100:
    print('A级')
elif 80 <= score < 90:
    print('B级')
elif 70 <= score < 80:
    print('C级')
elif 60 <= score < 70:
    print('D级')
elif 0 <= score < 59:
    print('E级')
else：
    print('对不起，您输入的成绩有误，不再成绩的有效范围内')

嵌套if的使用

answer=input('您是会员吗？y/n')
money=float(input('请输入您的购物金额：'))
#外层判断是否是会员
if answer=='y':
    if money >= 200：
        print('打八折,付款金额为：',money*0.8)
    elif money>=100:
        print('打九折,付款金额为：',money*0.9)
    else:
        print('不打折,付款金额为：',money)
else:
    if money>=200:
        print('打9.5折,付款金额为：',money*0.95
    else:
        print('不打折，付款金额为：',money)

条件表达式

''''num_a=int(input('请输入第一个整数'))
num_b=int(input('请输入第二个整数'))
#比较大小
if num_a>=num_b
  print(num_a,'大于等于',num_b)
else:
  print(num_a,'小于',num_b)''''
print('使用条件表达式进行比较')
#条件判断的结果为true，就执行左边的内容，为false，执行右侧的代码
print(str(num_a)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于'+str(num_b))

pass语句

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

#判断是否是会员
if answer == 'y':
    pass
else:
    pass

range的三种创建方式

#range()的三种创建方式

''''第一种方式，只有一个参数(小括号中只给一个数)''''
r = range(10) #[0,1,2,3,4,5,6,7,8,9],默认从0开始，默认相差1位步长
print(r)#range(0,10)
print(list(r))#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#用于查看range对象中的整数序列-->list是列表的意思

''''第二中创建方式，给了两个数(小括号中给了连个数)''''
r=range(1,10)#指定了起始值，从1开始，到10结束(不包含10),默认步长为1
print(list(r))#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

''''第三种创建方式,给了三个参数(小括号中给了三个数)''''
r=range(1,10,2)
print(list(r))#[1,3,5,7,9]
'''判断指定的整数在序列中是否存在in,not in'''
print(10 in r)#False,10不在当前的r这个整数系列中
print(9 in r)#True,9在当前的r这个序列中
print(10 not in r)#True

while循环结构

sum=0
a=0
while a<5:
    sum+=a
    a++
print('和为',sum)

while练习题

sum=0
a=1
while a<=100:
    if a%2==0:
        sum+=a
    a+=1
print('1-100之间的偶数和',sum)#因为print和while是对齐的，所以print没有进入while循环

for-in循环

for item in 'Python':#第一次取出来的是P,将P赋值给item,将item的值输出
   print(item)
#range() 产生一个整数序列---》也是一个可迭代对象
for i in range(10):
    print(i)#1 2 3 4 5 6 7 8 9
#如果在循环体中不需要使用自定义白能量，可将自定义变量写为“_”
for _ in range(5):
    print('人生苦短,我用Python')

print('使用for循环,计算1到100的偶数和')
sum=0#用于存储偶数和
for item in range(1,101):
    if item % 2==0:
        sum+=item
  
print('1到100之间的偶数和为：',sum)

输出100到999的水仙花数

for item in range(100, 1000):
    ge = item % 10
    shi = item // 10 % 10
    bai = item // 100

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

循环控制语句break

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

流程控制语句continue

for item in range(1, 51):
    if item % 5 != 0:
        continue
    print(item)

else语句

没有碰到break时执行else

#for和else搭配使用
for item in range(3):
    pwd = input('请输入密码：')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
else:
    print('对不起，三次密码均输入错误')
#while和else搭配使用
a = 0
while a < 3:
    pwd = input('请输入密码')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    a += 1
else:
    print('对不起,三次密码均不正确')

嵌套循环

# 输入一个三行四列的举行
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(str(i) + '*' + str(j) + '=' + str(i * j), end='\t')
#print(i,'*',j,'=',i*j,end='\t')
    print()

二重循环中的break

二重循环中的break和continue用于控制本层循环

列表

自己的感悟

列表让我想到了Excel表，他的括号是直上直下的，又联系到java里的列表就有list([ ])

·列表对应的英语单词是list—>list([])

列表的创建

"""创建列表的第一种方式，使用[]"""
lst = ['hello', 'world', 98]

'''创建列表的第二种方式,使用内置函数list()'''

lst2 = list(['hello', 'world', 98])
print()

列表的特点

1.列表元素按顺序有序排序

2.索引映射唯一一个数据

3.列表可以存储重复数据

4.任意数据类型混存

5.根据需要动态分配和回收内存

获取指定元素的索引

lst = ['hello', 'world', 98, 'hello']
print(lst.index('hello'))  # 如果列表中有相同元素只返回相同元素的第一个元素的索引
# print(lst.index('Python'))  # 'Python' is not in list
# print(lst.index('hello', 1, 3))#'hello' is not in list 在1~2的位置上查找
print(lst.index('hello', 1, 4))

获取列表中的单个元素

正向索引从0到N-1，举例list[0]

逆向索引你从-N到-1，举例lst[-N]

指定索引不存，抛出IndexError

lst = ['hello', 'world', 98, 'hello', 'world', 234]
# 获取索引为2的元素
print(lst[2])  # 98
# 获取索引为-3的元素
print(lst[-3])  # hello
# 获取索引为10的元素
print(lst[10])  # IndexError: list index out of range

列表元素的查询操作

# 判断指定元素在列表中是否存在
print('p' in 'python')
print('k' not in 'python')

lst = [10, 20, 'python', 'hello']
print(10 in lst)  # True
print(100 in lst)  # False
print(10 not in list)  # True

# 遍历
for item in lst:
    print(item)

列表元素的增加操作

# append() 向列表的末尾添加一个元素
lst = [10, 20, 30]
print('添加元素之前', lst, id(lst))  # 添加元素之前 [10, 20, 30] 2100054273728
lst.append(100)
print('添加元素之后', lst, id(lst))  # 添加元素之后 [10, 20, 30, 100] 2100054273728
print(list)  # <class 'list'>
# extend() 在列表的末尾只收添加一个元素
lst2 = ['hello', 'world']
# st.append(lst2)#将lst2作为一个元素添加到列表的末尾
# print(lst)  # [10, 20, 30, 100, ['hello', 'world']]
# 向列表的末尾一次性添加多个元素
lst.extend(lst2)
print(lst)
# 在指定位置上添加一个元素
lst.insert(1, 90)
lst3 = [True, False, 'hello']
# 在任意的位置上添加N多个元素
lst[1:] = lst3;
print(lst)

列表元素的删除操作

lst = [10, 20, 30, 40, 50, 60, 30]
lst.remove(30)  # 从列表中溢出一个元素，如果有重复元素只移第一个元素
print(lst)
lst.remove(100)  # [10, 20, 40, 50, 60, 30]

lst = [10, 20, 30, 40, 50, 60, 30]
# pop()根据索引移除元素
lst.pop(1)
print(lst)
lst.pop(6)
print(lst)  # pop index out of range

lst = [10, 20, 30, 40, 50, 60, 30]
# pop()根据索引移除元素
lst.pop(1)
print(lst)
lst.pop(5)
print(lst)  # pop index out of range
lst.pop()  # 如果不指定参数(索引),将删除列表中的最后一个元素
print(lst)

lst = [10, 20, 30, 40, 50, 60, 30]
print("------切片操作-删除至少一个元素，将产生一个新的列表对象")
new_list = lst[1:3]
print('原列表', lst)#原列表 [10, 20, 30, 40, 50, 60, 30]
print('切片后的列表', new_list)#切片后的列表 [20, 30]

'''不产生新的列表对象，二回删除原列表中的内容'''
lst = [10, 20, 30, 40, 50, 60, 30]
lst[1:3] = []
print(lst)  # [10, 40, 50, 60, 30]

"""清楚列表中的所有元素"""
lst = [10, 20, 30, 40, 50, 60, 30]
lst.clear()
print(lst)

"""del语句将列表对象删除"""
lst = [10, 20, 30, 40, 50, 60, 30]
del lst
print(lst)#name 'lst' is not defined

列表元素的修改操作

lst = [10, 20, 30, 40]
# 一次修改一个值
lst[2] = 100
print(lst)  # [10, 20, 100, 40]
lst[1:3] = [300, 400, 500, 600]  # [10, 300, 400, 500, 600, 40]
print(lst)

列表元素的排序操作

·常见的两种方式

·调用sort()方法，列有中的所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True，进行降序排序

·调用内置函数sorted(),可以指定reverse=True，进行降序排序，原列表不发生改变

lst = [20, 40, 10, 98, 54]
print('排序前的列表', lst, id(lst))  # 排序前的列表 [20, 40, 10, 98, 54] 3245910544000
# 开始排序,调用列表对象的sort方法,升序排序
lst.sort()
print('排序后的列表', lst, id(lst))  # 排序后的列表 [10, 20, 40, 54, 98] 1433208368896


# 通过指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)  # reverse=True 表示降序排序 reverse=False就是降序排序
print(lst)#[98, 54, 40, 20, 10]
lst.sort(reverse=False)
print(lst)#[10, 20, 40, 54, 98]



# 使用内置函数sorted()对列表进行排序，将产生一个新的列表对象
lst = [20, 40, 10, 98, 54]
print('原列表', lst)
# 开始排序
new_list = sorted(lst)
print(lst)
print(new_list)
# 指定关键字参数,实现列表元素的降序排序
desc_list = sorted(lst, reverse=True)
print(desc_list)

列表生成式

简称生成列表的公式

·语法格式：

​ [i*i for i in range(1,10)]

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]

'''列表元素的值为2,4,6,8,10'''
lst2=[i*2 for i in range(1,6)]
print(lst2)#[2, 4, 6, 8, 10]

字典

自己的感悟

字典嘛，让我想到了老师的棒棒，---->{}，

{‘张三’：100}：冒号显得很随意

字典dictionary，dict(name=‘jack’) ，"="像一个字典横着放在那

·字典对应的英语单词是dict---->dict()

什么是字典

·Python内置的数据结构之一，与列表一样时一个可变序列·以键值对的方式存储数据，字典是一个无序的序列

字典的创建

·最常用的方式：使用花括号

scores={‘张三’：100，‘李四’：98}

·使用内置函数dict()

dict(name=‘jack’,age=20)

"""使用{}创建字典"""
scores = {'张三': 100}
print(scores)  # {'张三': 100}
print(type(scores))  # <class 'dict'>

'''第二种方式dict()'''
student = dict(name='jack', age=20)
print(student)  # {'name': 'jack', 'age': 20}

'''空字典'''
d = {}
print(d)  # {}

字典元素的获取

scores = {'张三': 100, '李四': 98, '王五': 45}

'''第一种方式,使用[]'''
print(scores['张三'])  # 100
# print(scores['陈六'])#KeyError: '陈六'

'''第二种方式,使用get()方法'''
print(scores.get('张三'))  # 100
print(scores.get('陈六'))  # None
print(scores.get('马奇', 99))  # 99   99是在查找’马奇‘所对的value不存在时，提供第一个默认值

字典的增删改操作

"""key的判断"""
scores = {'张三': 100, '李四': 98, '王五': 45}
print('张三' in scores)  # True
print('张三' not in scores)  # False

del scores['张三']  # 删除指定的key-value对
scores.clear()  # 清空字典的元素
print(scores)  # False


#新增元素
scores = {'张三': 100, '李四': 98, '王五': 45}
scores['陈六'] = 98
print(scores)#{'张三': 100, '李四': 98, '王五': 45, '陈六': 98}

#修改元素
scores = {'张三': 100, '李四': 98, '王五': 45, '陈六': 98}
scores['陈六'] = 100
print(scores)

获取字典视图的三个方法

1、keys()------获取字典中所有key

2、values()------获取字典中所有value

3、items()------获取字典中所有key，values

scores = {'张三': 100, '李四': 98, '王五': 45}
# 获取所有的key
keys = scores.keys()
print(keys)  # dict_keys(['张三', '李四', '王五'])
print(type(keys))  # <class 'dict_keys'>
print(list(keys))  # ['张三', '李四', '王五']

# 获取所有的value
values = scores.values()
print(values)  # dict_values([100, 98, 45])
print(type(values))  # <class 'dict_values'>
print(list(values))  # [100, 98, 45]

# 获取所有的key-value对
items = scores.items()
print(items)  # dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
print(list(items))  # [('张三', 100), ('李四', 98), ('王五', 45)]
# 转换之后的列表元素是由元组组成的

字典元素的遍历

scores = {'张三': 100, '李四': 98, '王五': 45}
# 字典元素的遍历
for item in scores:
    print(item, scores[item], scores.get(item))
# 张三 100 100
# 李四 98 98
# 王五 45 45

字典的特点

1、字典中的所有元素都是一个key-value对，key不允许重复，value可以重复

2、字典中的元素是无序的

3、字典中的key必须是不可变对象

4、字典也可以根据需要动态地伸缩

5、字典会浪费较大的内存，是一种使用空间换时间的数据机构

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

d = {'name': '张三', 'nickname': '张三'}  # values可以重复的
print(d)

lst = [10, 20, 30]
lst.insert(1, 100)
print(lst)  # [10, 100, 20, 30

d = {lst: 100}  # unhashable type: 'list'
print(d)
'''不懂，可以再回来看一下'''

字典生成式

items = ['Fruits', 'Books', 'Others']
prices = [96, 78, 85]

d = {item.upper(): price for item, price in zip(items, prices)}
print(d)#{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}

知识点总结

字典的创建

1、使用{}花括号

2、内置函数dict()

3、字典生成式

常用操作

1、获取value

​ ·字典名[key]

​ ·字典名.get(key)

2、删除key-value对

​ del字典名[key]

3、修改/新增

​ 字典名[key]=value

4、in/not

元组

什么是元组

自己的感悟

·元组很圆 所以用（）包住元素，又因为它很圆滑，可以把括号去掉

·元组对应的英语单词是tuple—>tuple(())

·元组

·Python内置的数据结构之一，是一个不可变的序列

·不可变序列与可变序列

·不可变序列与可变序列

·不变序列:字符串、元组

​ ·不可变序列：没有增、删、改的操作

·可变序列：列表、字典

​ ·可变序列：可以对序列执行增、删、改操作，对象地址不发生更改

"""可变序列 列表，字典"""
lst = [10, 20, 45]
print(id(lst))  # 2190449651584
lst.append(300)
print(id(lst))  # 2190449651584


'''不可变序列，字符串，元组'''
s = 'hello'
print(id(s))#3209077469104
s = s + 'world'
print(id(s))#3209077476656
print(s)#helloworld

元组的创建方式

直接小括号

t = (‘Python’，‘hello’,90)

使用内置函数tuple()

t = tuple((‘Python’，‘hello’,90))

只包含一个元组的元素需要使用逗号和小括号

t=(10,)

'''第一种创建方式，使用()'''
t=('Python','world',98)
print(t)  # ('Python', 'world', 98)
print(type(t))  # <class 'tuple'>

'''第二种创建方式,使用内置函数tuple()'''
t2 = 'Python', 'world', 98  # 省略了小括号
print(t2)  # ('Python', 'world', 98)
print(type(t2))  # <class 'tuple'>

t3 = ('Python',)  # 如果元组中只有一个元素，逗号不能省略
print(t3)  # ('Python',)
print(type(t3))  # <class 'tuple'>

'''第二种方式,使用内置函数tuple()'''
t1 = tuple(('Python', 'world', 98))
print(t1)  # ('Python', 'world', 98)
print(type(t1))  # <class 'tuple'>

'''空元组的创建方式'''
'''空列表的创建方式'''
lst = []
lst1 = list()

d = {}
d2 = dict()

# 空元组
t4 = ()
t5 = tuple()

print('空列表', lst, lst1)  # 空列表 [] []
print('空字典', d, d2)  # 空字典 {} {}
print('空元组', t4, t5)  # 空元组 () ()

为什么要把元组设计成不可变序列

·在多任务环境下，同时操作对象时不需要加锁

·因此，在程序中尽量使用不可变序列

注意事项：

元组中存储的是对象的引用

a)如果元组中对象本身不可对象，则不能再引用其它对象

b)如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

t = [10, [20, 30], 9]
print(t)  # (10, [20, 30], 9)
print(type(t))  # <class 'tuple'>
print(type(t[0]), type(t[0]), id(t[0]))  # <class 'int'> <class 'int'> 2155089521232
print(type(t[1]), type(t[1]), id(t[1]))  # <class 'list'> <class 'list'> 2155091275648
print(type(t[2]), type(t[2]), id(t[2]))  # <class 'int'> <class 'int'> 2155089521200
'''尝试将t[1]修改为100'''
print(id(100))
# t[1] = 100 #元组是不允许修改元素的
'''由于[20,30]列表,而列表是可变序列，所以可以向列中添加元素，而列表中的内存地址不变'''
t[1].append(100)  # 向列表中添加元素
print(t,id(t[1]))  # [10, [20, 30, 100], 9]

元组的遍历

t = ('Python', 'world', 98)
'''第一种获取元组的方式，使用索引'''
print(t[0])  # Python
print(t[1])  # world
print(t[2])  # 98
#print(t[3])  # tuple index out of range

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

集合

自己的感悟

集合对应的英语单词是set()

什么是集合

·Python语言提供的内置数据结构

·与列表、字典一样都属于可变类型的序列

·集合是没有value的字典

集合的创建方式

"""第一种创建方式使用{}"""
s = {2, 3, 4, 5, 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([1, 2, 3, 4, 5, 5, 6, 6])
print(s2, type(s2))  # {1, 2, 3, 4, 5, 6} <class 'set'>

s3 = set((1, 2, 4, 4, 5, 65))
print(s3, type(s3))  # {65, 1, 2, 4, 5} <class 'set'>

s4 = set('python')
print(s4, type(s4))  # {'t', 'o', 'n', 'h', 'y', 'p'} <class 'set'>

s5 = set({12, 4, 34, 55, 66, 44})
print(s5, type(s5))  # {34, 66, 4, 55, 12, 44} <class 'set'>

# 定义一个空集合
s6 = {}  # dict字典类型
print(type(s6))  # <class 'dict'>

s7 = set()
print(type(s7))  # <class 'set'>

集合的相关操作

·集合元素的判断操作

·in或not in

·集合元素的新增操作

·调用add()方法，一次添中一个元素

·调用update()方法，至少添中一个元素

·集合元素的删除操作

·调用remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyErrot

·调用discard()方法，一次删除一个指定元素，如果指定的元素不存在不抛异常

·调用pop()方法，一次只删除一个任意元素

·调用clear()方法，清空集合

s = {10, 20, 30, 405, 60}
'''集合元素的判断操作'''
print(10 in s)  # True
print(100 in s)  # False
print(10 not in s)  # False
print(100 not in s)  # True
'''集合元素的新增操作'''
s.add(80)  # add一次添加一个元素
print(s)  # {80, 20, 405, 10, 60, 30}
s.update({200, 400, 300})  # 一次至少添加一个元素
print(s)  # {200, 10, 300, 80, 400, 20, 405, 60, 30}
s.update([100, 99, 8])
s.update((78, 64, 56))
print(s)  # {64, 99, 100, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}

'''集合元素的删除操作'''
s.remove(100)
print(s)  # {64, 99, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
# s.remove(500)#KeyError: 500
s.discard(500)  # {64, 99, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
print(s)
s.pop()
s.pop()
# s.pop(400)#set.pop() takes no arguments (1 given) pop方法不能添加参数
print(s)  # {200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
s.clear()
print(s)  # set()

集合间的关系

两个集合是否相等

·可以使用运算符==或！=进行判断

一个集合是否是另一个集合的子集

·可以调用方法issubset进行判断

·B是A的子集

一个集合是否是另一个集合的超集

·可以调用方法issuperset进行判断

·A是B的超集

两个集合是否没有交集

·可以调用方法isdisjojoint进行判断

"""两个集合是否相等(元素相同,就相等)"""
s = {10, 20, 30, 40}
s2 = {30, 40, 20, 10}
print(s == s2)  # True
print(s != s2)  # False

'''一个集合是否是另一个集合的子集'''
s1 = {10, 20, 30, 40, 50, 60}
s2 = {10, 20, 30, 40}
s3 = {10, 20, 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 #有交集为False
s4 = {100, 200, 300}

print(s2.isdisjoint(s4))  # True 没有交集为True

集合的数据操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g8xk58OU-1643201542071)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220120181531029.png)]

# (1)交集
s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
print(s1.intersection(s2))  # {40, 20, 30}
print(s1 & s2)  # {40, 20, 30}#intersection与&等价,交集操作
# (2)并集操作
print(s1.union(s2))
print(s1 | s2)  # union与|等价,并集操作
print(s1)  # {40, 10, 20, 30}
print(s2)  # {50, 20, 40, 60, 30}
# (3)差集操作
print(s1.difference(s2))  # {10}
print(s1 - s2)  # {10}
print(s1)
print(s2)

# (4)对称差集
print(s1.symmetric_difference(s2))#{50, 10, 60}
print(s1 ^ s2)#{50, 10, 60}

集合生成式

·用于生成集合的公式

{i*i for i in range(1,10)}

·将{}修改为[]j就是列表生成式

·没有元组生成式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2tWoObUM-1643201542071)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220120221831248.png)]

# 列表生成式

lst = [i * i for i in range(10)]
print(lst)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 集合生成式
s = {i * i for i in range(10)}
print(s)  # {0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

列表字典元组集合的比较

创建

列表
1、lst = [‘hello’, ‘world’, 98]

2、lst2 = list([‘hello’, ‘world’, 98])

字典
1、dit = {‘张三’: 100}

2、dit1 = dict(name=‘jack’, age=20)

元组
1、tup=(‘Python’,‘world’,98)

tup2 = (‘Python’,)

tup3 = ‘Python’, ‘world’, 98

2、tup4 = tuple((‘Python’, ‘world’, 98))

集合

1、s = {2, 3, 4, 5, 5, 6, 7, 7}

2、 s1 = set(range(6))

s2 = set([1, 2, 3, 4, 5, 5, 6, 6])

s3 = set((1, 2, 4, 4, 5, 65))

s4 = set({12, 4, 34, 55, 66, 44})

s5 = set(‘python’)# {‘t’, ‘o’, ‘n’, ‘h’, ‘y’, ‘p’}

索引

列表

获取指定元素的索引

lst = [‘hello’, ‘world’, 98, ‘hello’]
1、print(lst.index(‘hello’))
2、print(lst.index(‘hello’, 1, 4))

获取列表中的单个元素

lst = [‘hello’, ‘world’, 98, ‘hello’, ‘world’, 234]

1、print(lst[2]) # 98
print(lst[-3]) # hello
print(lst[10]) # IndexError: list index out of range

字典元素的获取

scores = {‘张三’: 100, ‘李四’: 98, ‘王五’: 45}

‘’‘第一种方式,使用[]’’’
print(scores[‘张三’]) # 100

print(scores[‘陈六’])#KeyError：‘陈六’

‘’‘第二种方式,使用get()方法’’’
print(scores.get(‘张三’)) # 100
print(scores.get(‘陈六’)) # None
print(scores.get(‘马奇’, 99)) # 99 99是在查找’马奇‘所对的value不存在时，提供第一个默认值

字符串

字符串的创建和驻留机制

字符串的驻留机制

·字符串

​ ·在Python中字符串是基本数据类型，是一个不可变的字符序列

​ 注：第一个不可变的序列是元组，第二个不可变的序列是字符串

·什么叫字符串驻留机制呢？

·仅保存一份相同且不可变字符串的方法，不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份拷贝，后续创建相同字符串时，不会开辟新空间，而是把该字符串的地址赋给新创建的变量

驻留机制的几种情况(交互模式)

·字符串的长度为0或1时

·符合标识符的字符串

s1=''
s2=''
print(s1 is s2)#True
s1='%'
s2='%'
print(s1 is s2)#True
s1='abc%'
s2='abc%'
print(s1==s2)#True 内容相同
print(s1 is s2)#False 地址不相同

·字符串只在编译时进行驻留，而非运行时

a='abc'
b='ab'+'c'
c=''.join(['ab',c])#join的操作是在程序运行的时候，程序在运行的时候当然会开辟一个新的空间
print(a is b)#True
print(a is c)#False
print(c)#abc

·[-5,256]之间的整数数字

a=-5
b=-5
print(a is b)#True
a=-6
b=-6
print(a is b)#False

sys中的intern方法强制2个字符串指向同一个对象

import sys
a='abc%'
b='abc%'
print(a is b)#False
a=sys.intern(b)
print(a is b)#True

PyCharm对字符串进行优化处理

就是之前为值false的结果在PyCharm编译器中是驻留的，是True的

字符串驻留机制的优缺点

·当需要值相同的字符串时，可以直接从字符串池里拿来使用，避免频繁的创建和销毁，替身效率和节约内存，因此拼接字符串和修改字符串是会比较影响性能的。

·在需要进行字符串拼接时建议使用str类型的join方法，而非+，因为join()方法是先计算出所有字符中的长度，然后再拷贝，只new一次对象，效率要比"+"效率高

字符串的常用操作

字符串的查询操作的方法

查询方法

·index() 查找子串substr第一次出现的位置，如果查找的子串不存在时，则抛出ValueError

·rindex()查找子串substr最后一次出现的位置，如果查找的子串不存在时，则抛出ValueError

·find()查找子串substr第一次出现的位置，如果查找的子串不存在时，则返回-1

·rfind()查找子串substr最后一次出现的位置，如果查找的子串不存在时，则返回-1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3K7jdltf-1643201542072)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220121115056706.png)]

# 字符串的查询操作
s = 'hello,hello'
print(s.index('lo'))  # 3
print(s.find('lo'))  # 3
print(s.rindex('lo'))  # 9
print(s.rfind('lo'))  # 9

# print(s.index('k'))# ValueError: substring not found
print(s.find('k'))  # -1
# print(s.rindex('k'))#ValueError: substring not found
print(s.rfind('k'))  # -1

字符串的大小写转换操作的方法

upper()

把字符串中所有字符都转成大写字母

lower()

把字符串中所有字符都转成小写字母

swapcase()

把字符串中所有大写字母转成小写字母，把所有小写字母都转成大写字母

capitalize()

把第一个字符转换成大写，把其余字符转换成小写

# 字符串中的大小写转换的方法
s = 'hello,python'
a = s.upper()  # 转成大写之后，会产生一个新的字符串对象
print(s)  # HELLO,PYTHON
print(a, id(a))  # HELLO,PYTHON 2190073744368
print(s, id(s))  # HELLO,PYTHON 1561669349040
print(s.lower())  # hello,python
print(s.lower(), id(s.lower()))  # hello,python 2207706857648
print(s, id(s))  # hello,python 2207706853296

s2 = 'hello,Python'
print(s2.swapcase())  # HELLO,pPYTHON

print(s2.title())  # Hello,Python

字符串内容对齐的方法

方法名称

center()

居中对齐，第一个参数指定宽度，第二个仓鼠指定填充符，第二个参数是可选的，默认是空格，如果设置款难度小于实际宽度则返回字符串

ljust()

左对齐，第1个参数指定宽度，第2个参数指定填充符，第二个参数是可选的，默认是空格如果设置宽度小于实际宽度则返回原字符串

rjust()

右对齐，第1个参数指定宽度，第2个参数指定填充符，第2个参数是可选的，默认是空格如果设置宽度小于实际宽度则返回原字符串、

zfill()

右对齐，左边用0填充，该方法只接收一个参数，用于指定字符串的宽度，如果指定的款难度小于等于字符串的长度，返回字符串本身

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
print(s.rjust(10))  # hello,Python

'''右对齐,使用0进行填充'''
print(s.zfill(20))#00000000hello,Python
print(s.zfill(10))#hello,Python
print('-8910'.zfill(8))#-0008910

字符串的劈分

split()

从字符串的左边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表

s='hello world Python'
lst=s.split()
print(lst)#['hello', 'world', 'Python']

以通过参数sep指定劈分字符串是劈分符

通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大劈分之后，剩余的子串会单独做成一部分

s1='hello|world|Python'
print(s1.split(sep='|'))#['hello', 'world', 'Python']
print(s1.split(sep='|',maxsplit=1))#['hello', 'world|Python']

rsplit()

从字符串的右边开始劈分，默认的劈分字符是空格字符串，返回的值都是一个列表

以通过参数sep指定劈分字符串是劈分符

通过参数maxsplit指定劈分字符串时的最大劈分次数，在经过最大次劈分之后，剩余的子串单独会做成一部分

s1 = 'hello|world|Python'
print(s1.split(sep='|'))  # ['hello', 'world', 'Python']
print(s1.split(sep='|', maxsplit=1))  # ['hello', 'world|Python']
s = 'hello world Python'
print(s.rsplit())  # ['hello', 'world', 'Python']
print(s.rsplit('|'))  # ['hello world Python']
print(s1.rsplit(sep='|', maxsplit=1))  # ['hello|world', 'Python']

字符串判断的相关方法

isidentifier()

判断指定的字符串是不是合法的标识符

isspace()

判断指定的字符串是否全部由空白字符组成(回车，换行，水平制表符)

isalpha()

判断指定的字符串是否全部由字母组成

isdecimal()

判断指定字符串是否全部由字母组成

isnumeric()

判断指定的字符串是否全部由数字组成

isalnum()

判断指定字符串是否全部由字母和数字组成

字符串操作的其他方法

字符串替换

replace()

第1个参数指定被替换的子串，第2个参数指定替换子串的字符串，该方法返回替换后得到的字符串，替换前的字符串不发生变化，调用该方法时可以通过第3个参数指定最大替换次数

字符串的合并

join()

将列表或元组中的字符串合并成一个字符串

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

lst = ['hello', 'java', 'Python']
print('|'.join(lst))  # hello|java|Python
print(''.join(lst))  # hellojavaPython

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

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

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

字符串的比较操作

运算符：>,>=,<,<=,==,!=

**比较规则：**首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，一次比较下去，指导两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较

**比较原理：**两个以上字符进行比较时，比较的是其ordinal value(原始值)，调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr，调用内置函数chr时指定ordinal value可以得到其对应的字符

a = b = 'Python'
c = 'Python'
print(a == b)  # True
print(b == c)  # True
print(a is b)  # True
print(a is c)  # True
print(id(a))  # 2592489649456
print(id(b))  # 2592489649456
print(id(c))  # 2592489649456

字符串的切片操作

print(s1)  # hello
print(s2)  # Python
print(newstr)  # hello!Python

print(s1)  # hello
print(s2)  # Python
print(newstr)  # hello!Python
print("-----------")
print(id(s))  # 2474006161840
print(id(s1))  # 2474010624176
print(id(s2))  # 2474010824176
print(id(s3))  # 2474010624048
print(id(newstr))  # 2474010639536

print("--------------切片[start:end:step]-----------------")
print(s[1:5:1])  # 从1开始截到5(不包含5),步长为1 ello
print(s[::2])  # 默认从0开始,没有写结束，默认字符串的最后一个元素，步长为2，两个元素之间的索引间隔为2 hloPto
print(s[::-1])  # 默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数 nohtyP,olleh
print(s[-6::1])  # 从索引为-6开始,到字符串的最后一个元素结束,步长为1 Python

格式化字符串

# (1)%占位符

name = '张三'
age = 20
print('我叫%s,今年%d岁' % (name, age))  # 我叫张三,今年20岁

# (2){}

print("我叫{0},今年{1}岁".format(name, age))  # 我叫张三,今年20岁

# {3}f-string

print(f'我叫{name},今年{age}岁')  # 我叫张三,今年20岁

print('%10d' % 99)#10表示的是宽度
print('%.3f' % 3.1415926)#.3表示是小数点后三位
#同时表示宽度和精度
print('%10.3f' % 3.1415926)#一共总宽度为10，小数点后3位

print('%10d' % 99)  #          99  10表示的是宽度
print('%.3f' % 3.1415926)#3.142
#同时表示宽度和精度
print('%10.3f' % 3.1415926)#     3.142 一共总宽度为10，小数点后3位

print('hellohello')  # hellohello
print('hellohello')

print('{0:.3f}'.format(3.1415926))#.3表示的是一共是3位数
print('{0:.3f}'.format(3.1415926))#.3f表示是3位小数
print('{:10.3f}'.format(3.1415926))#同时设置宽度和精度

字符串的编码与解码

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'))  # 解码

byte = s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))

函数

函数调用的参数传递 _ 位置实参 _ 关键字实参

# 位置实参
# 根据形参对应的位置进行实参传递
def calc(a, b):
    c = a + b
    return c


result = calc(10, 20)
print(result)

# 关键字实参
# 根据形参名称进行实参传递
res = calc(b=10, a=20)  # 等号左侧的变量的名称成为关键字参数
print(res)

函数的返回值

print(bool(0))  # False
print(bool(8))  # 非0的布尔值为True


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

'''函数的返回值
(1)如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】return可以省略不写
(2)函数的返回值,如果是1个,直接返回类型
(3)函数的返回值，如果是多个，返回的结果为元组
'''


def fun1():
    print('hello')
    # return脱了裤子放屁


fun1()


def fun2():
    return 'hello'


res = fun2()
print(res)


def fun3():
    return 'hello', 'world'


print(fun3())

'''False
True
([29, 23, 53, 55], [10, 34, 44])
hello
hello
('hello', 'world')
'''

函数参数定义_默认值参数

def fun(a, b=10):
    print(a, b)


# 函数的调用
fun(100)  # 100 10
fun(20, 30)  # 20 30

print('hello',end='\t')
print('world')#hello	world

函数的参数定义

个数可变的位置参数

定义函数，可能无法事先确定传递的位置实参的个数时，使用可变的位置参数

使用*定义个数可变的位置形参

结果为一个元组

个数可变的关键字形参

定义函数时，无法实现确定传递的关键字实参的个数时，使用可变的关键字形参

使用**定义个数可变的关键字形参

结果为一个字典

函数参数定义 _ 个数可变的位置形参 _ 个数可变的关键字形参

def fun(*args):  # 函数定义时的可变的位置参数
    # 为什么可变,因为传多少都可以
    print(args)
    print(args[0])


fun(10)
fun(10, 30)
fun(30, 405, 50)


def fun1(**args):
    print(args)


fun1(a=10)
fun1(a=20, b=30, c=40)

print('hello', 'world', 'java')

'''def fun2(*args,*a):
   pass
   以上代码,程序会报错，个数可变的位置参数，只能是1个
   def fun2(**args,**args):
    pass
    以上代码,程序会报错，个数可变的位置参数，只能是1个
   '''


def fun2(*args1, **args2):
    pass


'''def fun2(**args,**args):
    pass
    在一个函数的定义过程中，既有个数可变的关键字,也有个数可变的位置形参,要求,个数可变的位置形参,放在个数可变的关键字形参之前
'''

函数的参数总结

def fun(a, b, c):  # a,b,c在函数的定义处,所以是形式参数
    print('a=', a)
    print('b=', b)
    print('c=', c)


# 函数的调用
fun(10, 20, 30)  # 函数调用时的参数传递,称为位置传参
lst = [11, 22, 33]
fun(*lst)
print('----------------')
fun(a=100, c=300, b=200)  # 函数的调用,所以是关键字实参
dic = {'a': 111, 'b': 222, 'c': 333}
fun(**dic)  # 在函数调用时,将字典中的键值对都转换为关键字实参传入
'''
a= 10
b= 20
c= 30
a= 11
b= 22
c= 33
----------------
a= 100
b= 200
c= 300
a= 111
b= 222
c= 333
'''

def fun(a, b=10):  # b是在函数的定义处,所以b是形参,而且进行了赋值,所以b称为默认值形参
    print('a=', a)
    print('b=', b)


def fun2(*args):  # 个数可变的位置形参
    print(args)


def fun3(**args2):  # 个数可变的关键字形参
    print(args2)


fun2(10, 20, 30, 40)  # (10, 20, 30, 40)
fun3(a=11, b=22, c=33, d=44, e=55)


def fun4(a, b, *, c, d):  # 从*之后的参数,在函数调用时,只能采用关键字参数传递
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)


# 调用fun4函数
fun4(10, 20, 30, 40)  # 位置实参传递
fun4(a=10, b=20, c=30, d=40)  # 关键字实参传递
fun4(10, 20, c=30, d=40)  # 前两个参数，采用的是位置实参传递,而c,d采用的是关键字实参传递

'''需求,  c,d只能采用关键字实参传递'''

'''函数定义时的形参的顺序问题'''


def fun5(a, b, *, c, d, **args):
    pass


def fun6(*args, **args2):
    pass


def fun7(a, b=10, *args, **args2):
    pass

变量的作用域

变量的作用域

def fun(a, b):
    c = a + b  # c,就是全局变量,因为c在函数体内进行定义的变量,a,b为函数的形参,作用范围也是函数内部,相当于局部变量
    print(c)


# print(c),因为a、c超出了起作用的范围(超出了作用域)
# print(a)

name = '杨老师'#name的作用范围为函数内部和外部都可以使用-->成为全局变量
print(name)


def fun2():
    print(name)

#调用函数
fun2()

def fun3():
    global age #函数内部定义的变量,局部变量,局部变量使用global声明,这个变量实际上就变成了全局变量
    age=20
    print(age)
fun3()
print(age)

# 调用函数
fun2()

'''杨老师
杨老师
20
20
杨老师
'''

递归函数

什么是递归函数

如果在一个函数体内调用了该函数本身，这个函数就称为递归函数

递归的组成部分

递归调用与递归终止条件

递归的调用过程

每递归调用一次函数，都会在栈内存分配一个栈帧

每执行完一次函数，都会释放相应的空间

递归的优缺点

缺点：占用内存多，效率低下

优点：思路和代码简单

def fac(n):
    if n == 1:
        return 1
    else:
        res = n * fac(n - 1)
        return res


print(fac(6))#720

斐波那契数列

def fib(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fib(n - 1) * fib(n - 2)


# 斐波那契数列第六位上的数字
print(fib(6))

# 输出这个数列的前6位上的数字
for i in range(1, 7):
    print(fib(i))
    
'''def fib(n):
    if n == 1:
        return 1
    elif n == 2:
        return 1
    else:
        return fib(n - 1) * fib(n - 2)


# 斐波那契数列第六位上的数字
print(fib(6))

# 输出这个数列的前6位上的数字
for i in range(1, 7):
    print(fib(i))'''

Bug

Bug的常见类型

age = input('请输入你的年龄')
print(type(age))
if int(age) >= 18:
    print('成年人...')

1、漏了末尾的冒号，如if语句，循环语句，else子句等

2、缩进错误，该缩进的没缩进，不该缩进的瞎缩进

3、把英文符号写成中文符号，比如说：引号，冒号，括号

4、字符串拼接的时候，把字符串和数字拼在一起

5、没有定义变量，比如说while的循环条件的变量

6、“==”比较运算符合“=”赋值运算符的混用

知识不熟练导致的错误

（1）索引越界问题IndexError

lst=[11，22，33，44]

print(lst[4])

lst = [11, 22, 33, 44]

print(lst[3])

(2)append()方法的使用掌握不熟练

lst=[]

lst=append(‘A’,‘B’,‘C’)

print(lst)

lst=[]
lst.append('A')
lst.append('B')
lst.append('C')
print(lst)#['A', 'B', 'C']

思路不清晰导致

lst = [{'rating': [9.7], 'id': '1292052', 'type': ['犯罪'], 'title': '肖申克的救赎',
        'actors': ['蒂姆', '摩根']},
       {'rating': [9.6], 'id': '1291546', 'type': ['剧情'], 'title': '霸王别姬',
        'actors': ['张国荣', '张丰毅']},
       {'rating': [9.5], 'id': '1292720', 'type': ['剧情'], 'title': '阿甘正传',
        'actors': ['汤姆', '罗宾']}]

name = input('请输入您要查询的演员：')
for item in lst:  # 遍历列表 -->{} item是一个又一个的字典
    act_lst = item['actors']
    for actor in act_lst:  # 遍历字典,得到movie是一个字典中的key
        if name in actor:
            print(name, '出演了', item['title'])

'''actors = movie['actors']
   if name in actors:
   print(name + '出演了：' + movie)
'''

被动掉坑

被动掉坑：程序代码逻辑没有错，知识因为用户错误操作或者一些“例外情况”而导致的程序崩溃

**题目要求：**输入两个整数并进行除法运算

try:
    a = int(input('请输入第一个整数'))
    b = int(input('请输入第二个整数'))
    result = a / b
    print('结果为：', result)
except ZeroDivisionError:
    print('对不起,除数不允许为0')
except ValueError:
    print('只能输入数字串')
print('程序结束')

try-except-else结构

try:
    a = int(input('请输入第一个整数'))
    b = int(input('请输入第二个整数'))
    result = a / b
except BaseException as e:
    print('出错了', e)
else:
    print("计算结果为：",result)

try:    a = int(input('请输入第一个整数'))    
        b = int(input('请输入第二个整数'))    
        result = a / bexcept BaseException as e:    
        print('出错了', e)
else:    print("计算结果为：",result)
finally:    print('谢谢您的使用')python

Python中常见的异常类型

ZeroDivisionError除零

IndexError序列中没有此索引

KeyError映射中没有这个键

NameError未声明/初始化对象（没有属性）

SyntaxErrorPython语法错误

ValueError传入无效的参数

# print(10/0)#ZeroDivisionError
lst = [11, 22, 33, 44]
#print(lst[4])  # IndexError
#print(num)#NameError
#int a=20#SyntaxError
a=int('hello')#ValueError

traceback模块的使用

import traceback

try:
    print('-------------------------')
    print(1 / 0)
except:
    traceback.print_exc()

面向对象

类

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进行修饰,所以我是静态方法')

    # 类方法
    def cm(cls):
        print('我是类方法,因为我使用了classmethod进行修饰')


# 在类之外定义的成为函数，在类之内定义的成为方法
def drink():
    print('喝水')

类属性、类方法、静态方法的使用

**类属性：**类中方法外的变量成为类属性，被该类的所有对象多共享

类方法：使用@classmethod修饰的方法，使用类名直接访问的方法

静态方法：使用@staticmethod修饰的主法，使用类名直接访问的方法

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进行修饰,所以我是静态方法')

    # 类方法
    def cm(cls):
        print('我是类方法,因为我使用了classmethod进行修饰')


# 在类之外定义的成为函数，在类之内定义的成为方法
def drink():
    print('喝水')


# 类属性的使用方式
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()
print('----------------静态方法的使用方式---------------')
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('李四', 30)
print(id(stu1))
print(id(stu2))
stu2.gender = '女'  # 只为stu2动态绑定了性别
print(stu1.name, stu1.age)
print(stu2.name, stu2.age, stu2.gender)

stu1.eat()
stu2.eat()

#动态绑定方法
def show():
    print('定义在类之外的,称函数')

stu1.show=show
stu1.show()
#stu2.show()

'''1997157314512
1997157313120
张三 20
李四 30 女
张三在吃饭
李四在吃饭
定义在类之外的,称函数
'''

面向对象的三大特征_封装的实现方式

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()
#在类的外面使用name与age时
print(stu.name)
#print(stu.__age)
print(dir(stu))
print(stu._Student__age)#在类的外部可以通过 _Student__age 进行访问

继承及其实现方式

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


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


stu = Student('张三', 20, '1001')
teacher = Teacher('李四', 34, 10)

stu.info()
teacher.info()
'''
张三 20
李四 34'''
# 多继承
class A(object):
    pass


class B(object):
    pass


class C(A, B):
    pass

方法重写

方法重写

·如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其（方法体）进行重新编写

·子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法

Object类

·object类是所有类的父类，因此所有类都有object类的属性和方法。

·内置函数dir()可以查看指定对象所有属性

·Object有一个__str__()方法，用于返回一个’对象的描述’，对应与内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对__str__()进行重写

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return '我的名字是{0},今年{1}岁'.format(self.name, self.age)


stu = Student('张三', 20)
print(dir(stu))
print(stu)  # 默认调用__str__()这样的方法
print(type(stu))

'''['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']
我的名字是张三,今年20岁
<class '__main__.Student'>'''

多态的实现

多态就是"具有多种形态"，它指的是：几遍不知道一个变量所引用的对象到底是什么类型，任然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法

静态语言和动态语言关于多态的区别

·静态语言实现多态的三个必要条件

·继承

·方法重写

·父类引用指向子类对象

·动态语言的多态崇尚“鸭子类型”当看到一只鸟走起来想鸭子、游泳起来像鸭字、收起来也想鸭子，name这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为

特殊属性

class A:
    pass


class B:
    pass


class C(A, B):
    def __init__(self, name, age):
        self.name = name
        self.age = age


# 创建C类的对象
x = C('Jack', 20)  # x是C类型的一个实例对象
print(x.__dict__) #实例对象的属性字典
print(C.__dict__)
print(x.__class__)#输出了对象所属的类
print(C.__bases__)#C类的父类类型的元素
print(C.__base__)
print(A.__subclasses__())

'''
{'name': 'Jack', 'age': 20}
{'__module__': '__main__', '__init__': <function C.__init__ at 0x0000024C5F89DB80>, '__doc__': None}
<class '__main__.C'>
(<class '__main__.A'>, <class '__main__.B'>)
<class '__main__.A'>
'''

特殊方法

a = 20
b = 100
c = a + b  # 两个帧数类型的对象的相加操作
d = a.__add__(b)

print(c)
print(d)


class Student:
    def __init__(self, name):
        self.name = name

    def __add__(self, other):
        return self.name + other.name

    def __len__(self):
        return len(self.name)


stu1 = Student('张三')
stu2 = Student('李四')
s = stu1 + stu2  # 实现了两个对象的加法运算(因为在Student类中,编写__add__()特殊的方法)
print(s)
s = stu1.__add__(stu2)
print(s)
lst = [11, 22, 33, 44]
print(len(lst))  # len是内置函数len,可以计算列表的长度
print(lst.__len__())
print(len(stu1))

'''特殊属性 
__dict__
获得类对象或实例对象所绑定的所有属性和方法的字典

特殊方法
__len__()
通过重写__len__()方法,让内置函数len()的参数可以自定义类型
__add__()
通过重写__add__()方法,可使用自定义对象具有“+”功能
__new__()
用于创建对象
__init__()
对创建的对象进行初始化

'''

__new__与__init__演示创建对象的过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hh76Ig51-1643201542078)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220124114008841.png)]

class Person(object):

    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('p1这个Person类的实例对象的id:{0}'.format(id(p1)))

类的赋值与浅拷贝

变量的赋值操作

只是形成两个变量，实际上还是只想同一个对象

浅拷贝

Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象

深拷贝

使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同

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(cpu1)
print(cpu2)

# (2)类有浅拷贝
print('------------------------------')
disk = Disk()  # 创建一个硬盘类对象
computer = Computer(cpu1, disk)  # 创建一个计算机类的对象

# 浅拷贝
import copy

print(disk)
computer2 = copy.copy(computer)
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.cpu, computer3.disk)



<__main__.CPU object at 0x0000023E0FC21FD0>
<__main__.CPU object at 0x0000023E0FC21FD0>
------------------------------
<__main__.Computer object at 0x0000023E0FC21F70> <__main__.CPU object at 0x0000023E0FC21FD0> <__main__.Disk object at 0x0000023E0FC21FA0>
<__main__.Computer object at 0x0000023E0FC21190> <__main__.CPU object at 0x0000023E0FC21FD0> <__main__.Disk object at 0x0000023E0FC21FA0>

模块

创建模块

新建一个.py文件，名称尽量不要与Python自带的标准模块名称相同

导入模块

import 模块名称 [as 别名]

from 模块名称 import 函数/变量/类

import math  # 关于数学运算

print(id(math))
print(type(math))
print(math)
print(math.pi)
print('----------------------')
print(dir(math))
print(math.pow(2, 3), type(math.pow(2, 3)))
print(math.ceil(9.001))
print(math.floor(9.999))

'''
2855299925232
<class 'module'>
<module 'math' (built-in)>
3.141592653589793
----------------------
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
8.0 <class 'float'>
10
9'''

from math import pi

print(pi)
print(pow(2, 3))
# print(math.pow(2,8))

模块的导入

def add(a, b):
    return a + b


def div(a, b):
    return a / b

# 这个模块的名称是calc



import calc
print(calc.add(10,20))
print(calc.div(10,4))


from calc import add
print(add(10,20))

以主程序方式运行124

def add(a, b):
    return a + b


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

Python中的包

sys 与Python解释其及其环境操作相关的标准库

time提供与时间相关的各种函数的标准库

os提供了访问操作系统服务功能的标准库

calendar提供与日期相关的各种函数的标准库

urllib用于读取来自网上（服务器）的数据标准库

json用于使用Json序列化和反序列化对象

re用于在字符串中执行正则表达式匹配和替换

math提供标准算数运算函数的标准库

decimal用于进行精准控制运算精度、有效数位和四舍五入操作的十进制运算

logging提供了灵活的记录时间、错误、警告和调试信息的功能

import sys
import time
import urllib.request

print(sys.getsizeof(24))#28
print(sys.getsizeof(45))#28
print(sys.getsizeof(True))#28
print(sys.getsizeof(False))#24
print(time.time())#1643016733.717006
print(time.localtime(time.time()))#time.struct_time(tm_year=2022, tm_mon=1, tm_mday=24, tm_hour=17, tm_min=32, tm_sec=13, tm_wday=0, tm_yday=24, tm_isdst=0)

print(urllib.request.urlopen('http://www.baidu.com').read())

第三方模块的安装126

文件

编码格式的介绍

常见的字符编码格式

Python的解释器使用的是Unicode(内存)

py文件在磁盘上使用UTF-8存储（外存）

文件读写的原理_读取磁盘文件中的内容

·文件的读写俗称“IO操作”

·文件读写操作流程

·操作原理

file = open('a.txt', 'r')
print(file.readlines())
file.close()

常用的文件打开模式131

文件类型

按文件中数据的组织形式，文件分为以下两大类

**文本文件：**存储的是普通"字符"文本，默认为uincode字符集，可以使用记本事程序打开

**二进制文件：**把数据内容用“字节”进行存储，无法用记事本打开，必须使用专用的软件打开，举例：mp3音频文件，jpg图片，.doc文档等

r以值读模式打开文件，文件的指针将会放在文件的开头

w以只写模式打开文件，如果文件不存在则创建，如果文件存在，则覆盖原有内容，文件指针在文件的开头

a以追加模式打开文件，如果我呢间不存在则创建，文件指针在文件开头，如果文件存在，则在文件末尾住家内容，文件指针在源文件末尾

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

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

#w
file = open('b.txt', 'w')
file.write('Python')
file.close()
#b
src_file = open('b.txt', 'r')

target_file = open('copylogo.png', 'wb')

print(target_file.write(src_file.read()))

target_file.close()
src_file.close()

**read([size])**从文件中读取size个字节或字符的内容返回。若省略[size]，则读取到文件末尾，即一次读取文件所有内容

**readline()**从文本文件中读取一行内容

**readlines()**把文本文件中每一行都作为独立的字符串对象，并将这些对象放入列表返回

**write（str）**将字符串str内容写入文件

**writelines（s_list）**将字符串str内容写入文件

**writelines(s_list)**将字符串列表s_list写入文本文件，不添加换行符

seek把文件指针移动到新的位置，offset表示相对于whence的位置：offset：为正往结束方向移动，为负往开始方向移动 whence不同的值代表不同含义

0：从文件头开始计算默认值（默认值）

1：从当前位置开始计算

2：从文件末开始计算

**tell()**返回文件指针的当前位置

**flush()**把缓冲区的内容写入文件，但不关闭文件

**close()**把缓冲区的内容写入文件，同时关闭文件，释放对象相关资源

file = open('c.txt', 'a')
lst = ['java', 'go', 'python']
file.writelines(lst)
file.close()

#javagopython

file = open('a.txt', 'r')
file.seek(2)
print(file.read())
print(file.tell())
file.close()

with语句（上下文管理器）

·with语句可以自动管理上下文资源，不论什么原因跳出with都能确保文件正确的关闭，以此来大道释放资源的目的

class MyContentMgr(object):
    def __enter__(self):
        print('enter方法被调用执行了')
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("exit方法被调用执行了")

    def show(self):
        print('show()方法被调用执行了')


with MyContentMgr() as file:
    file.show()
    
#另一个文件
with open('a.txt', 'r') as file:
    print(file.read())

'''改进
with open('logo.png','rb') as src_file:
    with open('copy2logo.png','wb') as target_file:
        target_file.write(src_file.read())
'''

os模块的常用函数

import os
os.system('notepad.exe')
os.system('calc.exe')
#直接调用
os.startfile('C:\\Program Files (x86)\\Tencent\\TIM\\Bin\\tim.exe')

os模块是Python内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样。

os模块与os.path模块用于对目录或文件进行操作

import os
os.system('notepad.exe')
os.system('calc.exe')
#直接调用
os.startfile('C:\\Program Files (x86)\\Tencent\\TIM\\Bin\\tim.exe')

import os
print(os.getcwd())

**getcwd（）**返回当前的工作目录

**listdir(path)**返回指定路径下的文件和目录信息

**mkdir(path[,mode])**创建目录

**makedirs(path1/path2)**创建多级目录

**rmdir(path)**删除目录

**removedirs(path1/path2)**删除多级目录

**chdir(path)**将path设置为当前工作目录

import os
print(os.getcwd())

lst = os.listdir('../chap15')
print(lst)

os.mkdir('newdir2')
#os.makedirs('A/B/C/')

os.rmdir('newdir2')
os.removedirs('A/B/C')

os.path模块的常用方法

path模块操作目录相关函数

**abspath(path)**用于获取文件或目录的绝对路径

**exists(path)**用于判断文件或目录是否存在，如果存在返回True，否则返回False

**join(path，name)**将目录与目录或者文件名拼接起来

**splitext()**将目录与目录或者文件名拼接起来

**basename(path)**从一个目录中提取文件名

**dirname(path)**从一个路径中提取文件路径，不包括文件名

**isdir(path)**用于判断是否为路径

import os.path

print(os.path.abspath('demo10.py'))
print(os.path.exists('demo13py'), os.path.exists('demo10.py'))

剩下的听不懂

实操案例

实操案例一

任务1：向文件输出’奋斗成就更好的你’

"""一、使用print方式进行输出(输出的目的地是文件)"""
fp = open('C:/李林峰/text.txt', 'w')#open是打开创建文件的意思
print('奋斗成就更好的未来',file=fp)
fp.close()
'''二、使用文件的读写操作'''
with open('C:/李林峰/text2.txt', 'w') as file:
    file.write('奋斗成就更好的未来')

实操案例二

输出《红楼梦中的金陵十二钗》前5位

'''1  变量的赋值'''
name1='林黛玉'
name2='薛宝钗'
name3='贾元春'
name4='贾探春'
name5='史湘云'
print('1\t'+name1)
print('2\t'+name2)
print('3\t'+name3)
print('4\t'+name4)
print('5\t'+name5)
'''2种方式 列表'''
lst_name=['林黛玉','薛宝钗','贾元春','贾探春','史湘云']
lst_sig=['1','2','3','4','5']
for i in range(5):
    print(lst_sig[i],'\t',lst_name[i])
'''3种方式 字典'''
d={'1':'林黛玉','2':'薛宝钗','3':'贾元春','4':'贾探春','5':'史湘云'}
for key in d:
    print(key,d[key])
print('zip-----------')
for s,name in zip(lst_sig,lst_name):
    print(s,name)

图像音像勋章

print('\033[0:35m\t\t图像音像勋章\033[m')
print('\033[0:35m---------------------\033[m')

输出你的身体指标

height=170
weight=50.5
bmi=weight/(height+weight)
print('您的身高是:'+str(height))
print('您的体重是:'+str(weight))
print('您的BMI的指数是:'+'{:0.2f}'.format(bmi))

实操案例三

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0WIDthtU-1643201542079)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220125104315944.png)]

将指定的十进制数转换成二进制、八进制、十六进制

二进制 ------>binary system

八进制 ------>octonary number system 英 /ˈɒktənəri/

十进制 ------>decimalism 英 /ˈdesɪməlɪzəm/

def fun():

   num=int(input('请输入一个十进制的整数'))#将str转换成int类型
   print(num,'的二进制数是:',bin(num))#第一种写法,使用了个数可变的位置参数
   print(str(num)+'的二进制数为：'+bin(num))#第二种写法,使用“+”作为连接符(+的左右均为str类型)
   print('%s的二进制位:%s'%(num,bin(num)))#第三种写法,格式化字符串
   print('{0}的二进制数为：{1}'.format(num,bin(num)))#第三种写法,格式化字符串
   print(f'{num}的二进制数为:'{bin(num)})#第三种方式,格式化字符串
   print(f'{num}的八进制数为:'{oct(num)})
   print(f'{num}的十六进制数为:'{hex(num)})

if __name__ == '__main__':
     while True:
         try:
             fun()
             break#如果程序正常输出结束以后,我们再break
         except:
             print('只能输入整数！程序出错,请重新输入')

为自己手机充值

print('用户手机账户原有话费金额为:\033[0:35m8元\033[m')
money=int(input('请输入用户充值金额:'))
money+=8
print('当前的金额为:\033[0:35m',money,'元\033[m')
'''
用户手机账户原有话费金额为:8元
请输入用户充值金额:100
当前的金额为: 108 元
'''

计算能量的消耗

num=int(input('请输入您当天行走的步数:'))
calorie=num*28
print(f'今天共消耗了卡路里{calorie},即{calorie/1000}千卡')

'''
请输入您当天行走的步数:10000
今天共消耗了卡路里280000,即280.0千卡
'''

预测未来子女的身高

father_height=float(input('请输入父亲的身高:'))
mother_height=float(input('请输入母亲的身高:'))
son_height=(father_height+mother_height)*0.54
print('预测子女的身高为:{}cm'.format(son_height))

'''
请输入父亲的身高:170
请输入母亲的身高:168
预测子女的身高为:182.52cm'''

实操案例四

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QoNtIT0V-1643201542080)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220125114055615.png)]

支付密码的验证

pwd=input('支付宝支付密码:')
if pwd.isdigit():
    print('支付数据合法')
else:
    print('支付数字不合法,支付密码只能是数据')

print('-------------------------------------------')
print('支付数据合法' if pwd.isdigit() else '支付数字不合法,支付密码只能是数据')

模拟QQ账号登录

qq=input('请输入qq号:')
pwd=input('请输入密码:')
if qq=='1059630434' and pwd=='123':
    print('登陆成功')
else:
    print('对不起,账号或密码不正确')

商品价格大竞猜

import random
price=random.randint(1000,1500)
print('今日竞猜的商品为小米草地机器人:价格在[1000-1500]之间:')
guess=int(input())
if guess>price:
    print('大了')
elif guess<price:
    print('小了')
else:
    print('猜对了')
print('真实价格为:',price)

根据星座查看运势

d={
    '白羊座':'''1''',
    '金牛座':'''2'''
}
star=input('请输入您的星座查看近来运势:')
print(d.get(star))

'''请输入您的星座查看近来运势:白羊座
1'''

实操案例五

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d8g2lFsb-1643201542080)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220125121002601.png)]

循环输出26个字母对应的ASCll码值

x=97#代表的是a的ASCII值
for _ in range(1,27):
    print(chr(x),'--->',x)
    x+=1

print('-----------')
x=97
while x<123:
    print(chr(x),'-->',x)
    x+=1

模拟用户登录

for i in range(1,4):
    user_name=input('请输入用户名:')
    user_pwd=input('请输入密码:')
    if user_name=='admin' and user_pwd=='8888':
        print('登录成功')
        break
    else:
        print('用户名或密码不正确!!!')
        if i<3:
            print(f'您还有{3-i}次机会！！！')
else:#这个else的意思是当你的这三个循环都结束后就会执行这个else之后的语句
    print('对不起,三次均输入错误,请联系后台管理员')

猜数游戏

import random
rand=random.randint(1,100)
for i in range(1,11):
    num=int(input('在我心中有个数1-100,请你猜一猜'))
    if num<rand:
        print('小了')
    elif num>rand:
        print('大了')
    else:
        print('恭喜你猜对了')
        break
print(f'您一共猜了{i}次')
if i<3:
    print('真聪明')
elif i<=7:
    print('还凑合')
else:
    print('天哪,找杨老师学习折半算法！！！')

计算100-999之间的水仙花数

import math
for i in range(100,1000):
    if math.pow((i%10),3)+math.pow((i//10%10),3)+math.pow(i//100,3)==i:
        print(i)

实操案例六

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tu7ItCUe-1643201542081)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220126195422389.png)]

千年虫我来了

year=[82,89,88,86,85,00,99]
print('原列表',year)
for index,value, in enumerate(year):
    #print(index,value)
    if str(value)!='0':
        year[index]=int('19'+str(value))

    else:
        year[index]=int('200'+str(value))

print('修改之后的列表:',year)
#列表的排序
year.sort()
print('排序之后的列表为:',year)

京东购物流程

lst=[]
for i in range(0,5):
    goods=input('请输入商品编号和商品名称进入商品的入库,每次只能输入一件商品:\n')
    lst.append(goods)
for item in lst:
    print(item)

cart=[]
while True:
    num=input('请输入要购买的商品编号:')
    for item in lst:
        if item.find(num)!=-1:
            cart.append(item)
            break# 退出for
    if num=='q':
        break #退出while循环
print('您购物车里已经选好的商品为:')
for i in range(len(cart)-1,-1,-1):
    print(cart[i])

实操案例七

根据星座测试性格特点

key=input('请输入您的星座名称')
flag=True
for item in d:
    if key==item:
        flag=True
        print(key,'的性格特点为:',d.get(key))
        break
    else:
        flag=False
if not flag:
    print('对不起,您输入的星座有误')

模拟12306货车票订票下单

dict_ticket={'G120':['天津-上海','18:05'],
             'G153':['北京-天津','18:15']}
print('车次\t\t出发站-到达站\t\t')
for item in dict_ticket:
    print(item,end=' ')
    for i in dict_ticket[item]:
        print(i,end='     ')
    print()#换行
#请输入要购买的车次
train_no=input('请输入要购买的车次:')
persons=input('请输入乘车人，如果是多人请使用逗号分隔')
s=f'您已购买了{train_no}次列表'
s_info=dict_ticket[train_no]#获取车次详细信息
s+=s_info[0]+' '+s_info[1]+' 开'
print(f'{s}请{persons}尽快取走纸质车票.')

实操案例八

我的咖啡馆你做主

print('本店经营的咖啡有:')
for index,item in enumerate(coffee_name):
    print(index+1,',',item,end='   ')

index=int(input('\n请输入您喜欢的咖啡编号:'))
if 0<=index<=len(coffee_name):
    print(f'您的咖啡[{coffee_name[index-1]}]好了,请您慢用')

Python print输出带颜色 总结

https://mp.weixin.qq.com/s?src=11&timestamp=1643077913&ver=3579&signature=Xs5i8fOba3Gvnk6VoReCQEZbFoRsxdHCv78bIkAR83AXabyIBVQXrSpTxpM7XqJrsF1K9JCf8l4erybJS7kfqksl2v6e0J2*SbQzGq-ZSelf-ULL9K3d7u970gXII3nP&new=1

这篇关于python初学的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！