Python输入一个32位的有符号整数 python输入123输出321的编程

目录

• 1、输出函数print
• 2、转义字符
• 3、Python中的标识符和保留字
• 4、变量的定义和使用
• 5、Python中常见的数据类型
• 6、数据类型转换
• 7、Python中的注释
• 8、input函数的使用
• 9、运算符
• 10、对象的布尔值
• 11、程序的组织结构
• 12、pass语句
• 13、range函数的使用
• 14、一些数值运算函数
• 15、复数类型
• 16、流程控制语句
• 17、else语句
• 18、列表
• 19、字典
• 20、元组
• 21、集合
• 22、列表、字典、元组、集合总结
• 23、字符串
• 24、函数
• 25、Bug
• 26、类与对象
• 27、面向对象的三大特征
• 28、类的赋值、浅拷贝和深拷贝
• 29、模块
• 30、文件
• 31、目录操作

1、输出函数print

#输出数字
print(520)

#输出字符串
print('helloworld')
print("helloworld")

#输出含有运算符的表达式
print(3+1)

#不进行换行输出（输出内容在一行当中）
print('hello','world','Python')

输出结果：

520
helloworld
helloworld
4
hello world Python

2、转义字符

例如：

#转义字符
print('hello\nworld')
print('hello\tworld')
print('helloooo\tworld')
print('hello\rworld')
print('hello\bworld')

print('http:\\\\www.baidu.com')

#原字符，如果不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加上r或R
print(r'hello\nworld')
#注意事项，最后一个字符不能是反斜杠
#print(r'hello\nworld\')    #错误
print(r'hello\nworld\\')    #正确

输出结果：

hello
world
hello	world				#注意\t的结果，这里空了3个空格，而下一行空了4个
helloooo	world
world
hellworld
http:\\www.baidu.com
hello\nworld
hello\nworld\\

3、Python中的标识符和保留字

4、变量的定义和使用

例如：

name = '马丽亚'
print(name)
print('标识',id(name))
print('类型',type(name))
print('值',name)

输出结果：

马丽亚
标识 2166142799568
类型 <class 'str'>
值 马丽亚

5、Python中常见的数据类型

（1）整数类型(int)

整数的不同进制表示方式：

十进制 -> 默认的进制

二进制 -> 以0b开头

八进制 -> 以0o开头

十六进制 -> 以0x开头

例如：

print('十进制',118)
print('二进制',0b10101111) #二进制以0b开头
print('八进制',0o176)      #八进制以0o开头
print('十六进制',0x1EAF)   #十六进制以0x开头

输出结果：

十进制 118
二进制 175
八进制 126
十六进制 7855

（2）浮点类型(float)

print(1.1+2.2)
print(1.1+2.1)

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

输出结果：

3.3000000000000003
3.2
3.3

（3）布尔类型(bool)

例如：

f1 = True
f2 = False
print(f1,type(f1))
print(f2,type(f2))

print(f1 + 1)
print(f2 + 1)

输出结果：

True <class 'bool'>
False <class 'bool'>
2
1

（4）字符串类型

Python为何提供2类共4种字符串表示方式？原因：

6、数据类型转换

（1）str()函数：

a = 10
b = 198.8
c = False

print(str(a))
print(str(b))
print(str(c))

输出结果：

10
198.8
False

（2）int()函数：

s1 = 128
f1 = 98.7
s2 = '76.77'
f2 = True
s3 = 'hello'

print(int(s1))
print(int(f1))
#print(int(s2))     #报错，因为此字符串为小数串
print(int(f2))
#print(int(s3))     #报错，因为str转成int类型时，字符串必须为数字串（整数），非数字串是不允许转换的

输出结果：

128
98
1

（3）float函数()

s1 = '128.98'
s2 = '76'
f1 = True
s3 = 'hello'
i = 98

print(float(s1))
print(float(s2))
print(float(f1))
#print(int(s3))     #报错，字符串中的数据如果是非数字串，则不允许转换
print(float(i))

输出结果：

128.98
76.0
1.0
98.0

7、Python中的注释

8、input函数的使用

例如：

str = input('歪比歪比 ')
print(str)

输出结果：

歪比歪比 歪比巴布
歪比巴布

9、运算符

（1）算术运算符

举例：

print(1 + 1)    #加法运算
print(1 - 1)    #减法运算
print(2 * 4)    #乘法运算
print(11 / 2)   #除法运算
print(11 // 2)  #整除运算
print(11 % 2)   #取余运算
print(2 ** 3)   #幂运算，2的3次方

输出结果：

2
0
8
5.5
5
1
8

举例：

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

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

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

输出结果：

2
2
-3
-3
-3
3

（2）赋值运算符

链式赋值：

a = b = c = 20
print(a,id(a))
print(b,id(b))
print(c,id(c))

20 140711366105344
20 140711366105344
20 140711366105344

参数赋值：

a = 20
a += 30
print(a)

a -= 10
print(a)

a *= 2
print(a,type(a))    #int

a /= 3
print(a,type(a))    #float

a //= 2
print(a,type(a))    #float

a %= 3
print(a,type(a))    #float

50
40
80 <class 'int'>
26.666666666666668 <class 'float'>
13.0 <class 'float'>
1.0 <class 'float'>

解包赋值：

a,b,c = 20,30,40
print(a,b,c)

#a,b = 20,30,40   报错，因为变量的个数和值的个数不相同

print('---交换两个变量的值---')
a,b = 10,20
print('交换之前：',a,b)
#交换
a,b = b,a
print('交换之后：',a,b)

20 30 40
---交换两个变量的值---
交换之前： 10 20
交换之后： 20 10

（3）比较运算符

例如：

a = 10
b = 10
print(a == b)   #True，说明a与b的value相等
print(a is b)   #True，说明a与b的id标识相等

lst1 = [11,22,33,44]
lst2 = [11,22,33,44]
print(lst1 == lst2)
print(lst1 is lst2)
print(id(lst1))
print(id(lst2))
print(a is not b)
print(lst1 is not lst2)

输出结果：

True
True
True
False
3169042899072
3169042901248
False
True

（4）布尔运算符

例如：

#-----------not 对bool类型操作数取反-----------
f1 = True
f2 = False
print(not f1)
print(not f2)

#-----------in 与 not in-----------
str = 'helloworld'
print('w' in str)
print('k' in str)
print('w' not in str)
print('k' not in str)

输出结果：

False
True
True
False
False
True

（5）位运算符

（6）运算符的优先级

10、对象的布尔值

例如：

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

False
False
False
False
False
False
False
False
False
False
False
False

应用举例：

age = int(input("请输入您的年龄："))

if age:
    print(age)
else:
    print("年龄为：",age)

请输入您的年龄：0
年龄为： 0

11、程序的组织结构

（1）顺序结构

（2）选择结构

A.单分支结构

money = 1000
temp = int(input("请输入取款金额："))
if money >= temp:
    money -= temp;
    print('取款成功，余额为：',money)

请输入取款金额：300
取款成功，余额为： 700

B.双分支结构

num = int(input('请输入一个整数：'))

if  num % 2 == 0:
    print(num,'是偶数')
else:
    print(num,'是奇数')

请输入一个整数：5
5 是奇数

C.多分支结构

score = int(input('请输入一个成绩：'))

if 90 <= score <= 100:
    print('A级')
elif score >= 80 and score <= 89:
    print('B级')
elif score >= 70 and score <= 79:
    print('C级')
elif score >= 60 and score <= 69:
    print('D级')
elif score >= 50 and score <= 59:
    print('E级')
else:
    print('成绩不在有效范围内')

请输入一个成绩：80
B级

D.嵌套if

E.条件表达式

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(str(num_a) + '大于等于' + str(num_b) if num_a >= num_b else str(num_a) + '小于' + str(num_b))

请输入第一个整数：20
请输入第二个整数：30
20小于30

（3）循环结构
循环的分类：while、for-in

a.while循环的语法结构

while 条件表达式:
	条件执行体(循环体)

b.for-in循环

for item in "Python":
    print(item)

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

print()

#如果在循环体中不需要使用到自定义变量，可将自定义变量写为"_"
for _ in range(5):
    print("人生苦短，我用Python")

P
y
t
h
o
n
0 1 2 3 4 5 6 7 8 9
人生苦短，我用Python
人生苦短，我用Python
人生苦短，我用Python
人生苦短，我用Python
人生苦短，我用Python

12、pass语句

例如：

answer = input("您是会员吗？y/n")

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

13、range函数的使用

#range()的三种创建方式
#第一种创建方式：一个参数
r = range(10)   #默认从0开始，默认步长为1
print(r)
print(list(r))  #查看range对象中的整数序列

#第二种创建方式：两个参数
r = range(1,10) #指定起始值从1开始，到10结束(不包含10)，默认步长为1
print(list(r))

#第三种创建方式：三个参数
r = range(1,10,2)
print(list(r))

#使用in,not in判断指定的整数是否在序列中
print(10 in r)
print(9 in r)
print(10 not in r)
print(9 not in r)

range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 3, 5, 7, 9]
False
True
True
False

14、一些数值运算函数

15、复数类型

16、流程控制语句

（1）break语句

（2）continue语句

二重循环中的break和continue语句：

17、else语句

for item in range(3):
    pwd = input("请输入密码：")
    if pwd == "8888":
        print("密码正确")
        break
    else:
        print("密码不正确")
else:
    print("对不起，三次密码均输入错误")

请输入密码：8
密码不正确
请输入密码：88
密码不正确
请输入密码：888
密码不正确
对不起，三次密码均输入错误

18、列表

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

2088285511808
<class 'list'>
['hello', 'world', 98]

（1）列表的创建

lst = ['hello','world',98]

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

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

内存示意图：

（2）列表的特点

（3）列表元素的查询操作

lst = ['hello','world',98,'hello']
print(lst.index('hello'))   #如果列表中有相同的元素只返回列表中相同元素的第一个元素的索引
#print(lst.index('Python')) #ValueError: 'Python' is not in list
#print(lst.index('hello',1,3))   #ValueError: 'hello' is not in list

print(lst.index('hello',1,4))

0
3

lst = ['hello','world',98,'hello','world',234]

print(lst[2])

print(lst[-3])

#print(lst[10])     #IndexError: list index out of range

98
hello

lst = [10,20,30,40,50,60,70,80]

print(lst[1:6])
print(lst[1:6:])
print(lst[1:6:2])
print(lst[:6:2])
print(lst[1::2])

#步长为负数的情况
print(lst[::-1])
print(lst[7::-1])
print(lst[6:0:-2])

[20, 30, 40, 50, 60]
[20, 30, 40, 50, 60]
[20, 40, 60]
[10, 30, 50]
[20, 40, 60, 80]
[80, 70, 60, 50, 40, 30, 20, 10]
[80, 70, 60, 50, 40, 30, 20, 10]
[70, 50, 30]

（4）列表元素的添加操作

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

lst2 = ['hello','world']
lst.append(lst2)    #将lst2做为一个元素添加到列表的末尾
print(lst)

#向列表的末尾一次性添加多个元素
lst.extend(lst2)
print(lst)

#在任意位置上添加一个元素
lst.insert(1,90)
print(lst)

#在任意位置上添加N多个元素
lst3 = [True,False,'hello']
lst[1:] = lst3
print(lst)

添加元素之前 [10, 20, 30] 1423446384832
添加元素之后 [10, 20, 30, 100] 1423446384832
[10, 20, 30, 100, ['hello', 'world']]
[10, 20, 30, 100, ['hello', 'world'], 'hello', 'world']
[10, 90, 20, 30, 100, ['hello', 'world'], 'hello', 'world']
[10, True, False, 'hello']

（5）列表元素的删除操作

lst = [10,20,30,40,50,60,30]

lst.remove(30)  #从列表中移除一个元素，如果有重复元素只移第一个元素
print(lst)
#lst.remove(100) #ValueError: list.remove(x): x not in list

#pop() 根据索引移除元素
lst.pop(1)
print(lst)
#lst.pop(5)  #IndexError: pop index out of range
lst.pop()   #如果不指定参数(索引)，将删除列表中的最后一个元素
print(lst)

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

#不产生新的列表对象，而是删除原列表中的内容
lst[1:3] = []
print(lst)

#清除列表中的所有元素
lst.clear()
print(lst)

#del语句将列表对象删除
del lst
#print(lst)  #NameError: name 'lst' is not defined

[10, 20, 40, 50, 60, 30]
[10, 40, 50, 60, 30]
[10, 40, 50, 60]
原列表： [10, 40, 50, 60]
切片后的列表： [40, 50]
[10, 60]
[]

（6）列表元素的修改操作

lst = [10,20,30,40]

#一次修改一个值
lst[2] = 100
print(lst)

#切片赋值
lst[1:3] = [300,400,500,600]
print(lst)

[10, 20, 100, 40]
[10, 300, 400, 500, 600, 40]

（7）列表元素的排序操作

lst = [20,40,10,98,54]
print('排序前的列表：',lst,id(lst))

#开始排序，调用列表对象的sort方法，默认升序排序
lst.sort()
print('排序后的列表：',lst,id(lst))

#通过指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse=True)  #reverse = True表示降序排序，reverse = False表示升序排序
print(lst)
lst.sort(reverse=False)
print(lst)

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

排序前的列表： [20, 40, 10, 98, 54] 1534626373760
排序后的列表： [10, 20, 40, 54, 98] 1534626373760
[98, 54, 40, 20, 10]
[10, 20, 40, 54, 98]
原列表： [20, 40, 10, 98, 54]
[10, 20, 40, 54, 98]
[98, 54, 40, 20, 10]

（8）列表生成式

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

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

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 4, 9, 16, 25, 36, 49, 64, 81]

19、字典

（1）什么是字典

（2）字典的实现原理

（3）字典的创建

#使用{}创建字典
scores = {'张三':100,'李四':98,'王五':45}
print(scores)
print(type(scores))

#使用dict()创建字典
student = dict(name = 'jack',age = 20)
print(student)

#创建空字典
d = {}
print(d)

{'张三': 100, '李四': 98, '王五': 45}
<class 'dict'>
{'name': 'jack', 'age': 20}
{}

（4）字典元素的获取

#获取字典的元素
scores = {'张三':100,'李四':98,'王五':45}
#使用[]获取
print(scores['张三'])
#print(scores['陈六']) #KeyError: '陈六'

#使用get()获取
print(scores.get('张三'))
print(scores.get('陈六'))
print(scores.get('麻七',-1))  #-1是在查找'麻七'所对的value时，如果不存在，则输出所提供的值-1

100
100
None
-1

（5）字典元素的增、删、改操作

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

del scores['张三']    #删除指定的key-val对
print(scores)

scores.clear()  #清空字典的元素
print(scores)

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

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

True
False
{'李四': 98, '王五': 45}
{}
{'陈六': 98}
{'陈六': 100}

（6）获取字典视图

scores = {'张三':100,'李四':98,'王五':45}
#获取所有的key
keys = scores.keys()
print(keys)
print(type(keys))
print(list(keys))   #将所有的key组成的视图转成列表

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

#获取所有的key-val对
items = scores.items()
print(items)
print(type(items))
print(list(items))  #转换之后的列表元素是由元组组成

dict_keys(['张三', '李四', '王五'])
<class 'dict_keys'>
['张三', '李四', '王五']
dict_values([100, 98, 45])
<class 'dict_values'>
[100, 98, 45]
dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
<class 'dict_items'>
[('张三', 100), ('李四', 98), ('王五', 45)]

（7）字典元素的遍历

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

张三 100
李四 98
王五 45

（8）字典的特点

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

d = {'name':'张三','nikename':'张三'}   #value可以重复
print(d)

{'name': '李四'}
{'name': '张三', 'nikename': '张三'}

（9）字典生成式

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

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

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

{'Fruits': 96, 'Books': 78, 'Others': 85}
{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}

20、元组

（1）什么是元组

#可变序列：列表、字典
#可变序列：列表、字典
lst = [10,20,45]
print(id(lst))
lst.append(300)
print(id(lst))  #地址不变

#不可变序列：字符串、元组
s = 'hello'
print(id(s))
s = s + 'world'
print(id(s))    #地址改变
print(s)

2521678880896
2521678880896
2521678876272
2521680170864
helloworld

（2）元组的创建方式

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

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

t3 = ('Python')
print(t3)
print(type(t3))

t4 = ('Python',)    #如果元组中只有一个元素，逗号不能省
print(t4)
print(type(t4))

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

#创建空元组
t5 = ()
t6 = tuple()
print(t5,t6)

('Python', 'world', 98)
<class 'tuple'>
('Python', 'world', 98)
<class 'tuple'>
Python
<class 'str'>
('Python',)
<class 'tuple'>
('Python', 'world', 98)
<class 'tuple'>
() ()

（3）为什么要将元组设计成不可变序列

举例：

t = (10,[20,30],9)
print(t,type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))

#尝试将t[1]修改为100
#t[1] = 100  #TypeError: 'tuple' object does not support item assignment 元组不允许修改元素

#由于[20,30]是列表，而列表是可变序列，所以可以向列中添加元素，而列表的内存地址不变
t[1].append(100)    #向列表中添加元素
print(t,id(t[1]))

(10, [20, 30], 9) <class 'tuple'>
10 <class 'int'> 140704753784768
[20, 30] <class 'list'> 2802547236928
9 <class 'int'> 140704753784736
(10, [20, 30, 100], 9) 2802547236928

（4）元组的遍历

t = ('Python','world',98)
#使用索引遍历元组
print(t[0],t[1],t[2])

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

Python world 98
Python
world
98

21、集合

（1）集合的概述与创建

#使用{}创建
s = {2,3,4,5,5,6,7,7}
print(s)    #集合中的元素不会重复

#使用set()创建
s1 = set(range(6))
print(s1,type(s1))

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

s3 = set((1,2,4,4,5,65))
print(s3,type(s3))  #集合中的元素是无序的

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

s5 = set({12,4,34,55,66,44,4})
print(s5,type(s5))

#定义一个空集合
s6 = {}     #这样定义的是空字典
print(type(s6))

s7 = set()
print(type(s7))

{2, 3, 4, 5, 6, 7}
{0, 1, 2, 3, 4, 5} <class 'set'>
{1, 2, 4, 5, 6} <class 'set'>
{65, 1, 2, 4, 5} <class 'set'>
{'t', 'y', 'o', 'P', 'h', 'n'} <class 'set'>
{34, 66, 4, 55, 12, 44} <class 'set'>
<class 'dict'>
<class 'set'>

（2）集合的相关操作

s = {10,20,30}
#集合元素的判断操作
print(10 in s)
print(100 in s)

#集合元素的添加操作
s.add(80)   #一次添加一个元素
print(s)
s.update({200,400})   #一次至少添加一个元素
print(s)
s.update([100]) #参数可以是列表类型
s.update((78,50))  #参数可以是元组类型
print(s)

#集合元素的删除操作
s.remove(100)
print(s)
#s.remove(500)   #若删除的元素不存在，会报错，KeyError: 500
s.discard(500)  #对于discaard()函数，若删除的元素不存在，不会报错
print(s)

s.pop() #删除一个任意元素
print(s)
s.pop()
print(s)

s.clear()   #清空集合
print(s)

True
False
{80, 10, 20, 30}
{80, 400, 20, 200, 10, 30}
{200, 10, 78, 80, 400, 20, 30, 100, 50}
{200, 10, 78, 80, 400, 20, 30, 50}
{200, 10, 78, 80, 400, 20, 30, 50}
{10, 78, 80, 400, 20, 30, 50}
{78, 80, 400, 20, 30, 50}
set()

（3）集合间的关系

#判断两个集合是否相等(元素相同就相等)
s1 = {10,20,30,40}
s2 = {30,40,20,10}
print(s1 == s2)
print(s1 != s2)

#判断一个集合是否是另一个集合的子集
s1 = {10,20,30,40,50,60}
s2 = {10,20,30,40}
s3 = {10,20,90}
s4 = {100,200,300}
print(s2.issubset(s1))
print(s3.issubset(s1))

#判断一个集合是否是另一个集合的超集
print(s1.issuperset(s2))
print(s1.issuperset(s3))

#判断两个集合是否没有交集
print(s2.isdisjoint(s3))
print(s2.isdisjoint(s4))

True
False
True
False
True
False
False
True

（4）集合的数学操作

#求交集
s1 = {10,20,30,40}
s2 = {20,30,40,50,60}
print(s1.intersection(s2))
print(s1 & s2)  #intersection()与 & 等价，都是交集操作

#求并集
print(s1.union(s2))
print(s1 | s2)  #union()与 | 等价，都是并集操作

#求差集
print(s1.difference(s2))
print(s1 - s2)  #difference()与 - 等价，都是差集操作

#求对称差集
print(s1.symmetric_difference(s2))
print(s1 ^ s2)  #symmetric_difference()与 ^ 等价，都是对称差集操作

{40, 20, 30}
{40, 20, 30}
{40, 10, 50, 20, 60, 30}
{40, 10, 50, 20, 60, 30}
{10}
{10}
{50, 10, 60}
{50, 10, 60}

（5）集合生成式

#列表生成式
lst = [i*i for i in range(10)]
print(lst)

#集合生成式
s = {i*i for i in range(10)}
print(s)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
{0, 1, 64, 4, 36, 9, 16, 49, 81, 25}

22、列表、字典、元组、集合总结

23、字符串

（1）字符串的创建与驻留机制

a = 'Python'
b = "Python"
c = '''Python'''
print(a,id(a))
print(b,id(b))
print(c,id(c))

Python 2787940607344
Python 2787940607344
Python 2787940607344

注意上图中情况的前提是在交互模式下

（2）字符串的常用操作①字符串的查询操作

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

3
3
9
9
-1
-1

②字符串的大小写转换操作

s = 'hello,Python'
s1 = s.upper()  #转换之后，会产生一个新的字符串对象
print(s1,id(s1))
print(s,id(s))

s2 = s.lower()
print(s2,id(s2))
print(s,id(s))

print(s.swapcase())

print(s.title())

HELLO,PYTHON 1507097429936
hello,Python 1507096465264
hello,python 1507097428400
hello,Python 1507096465264
HELLO,pYTHON
Hello,Python

③字符串的内容对齐操作

s = 'hello,Python'
#居中对齐
print(s.center(20,'*'))

#左对齐
print(s.ljust(20,'*'))
print(s.ljust(20))
print(s.ljust(10))

#右对齐
print(s.rjust(20,'*'))
print(s.rjust(20))
print(s.rjust(10))

#右对齐，使用0进行填充
print(s.zfill(20))
print(s.zfill(10))
print('-8910'.zfill(8))

****hello,Python****
hello,Python********
hello,Python        
hello,Python
********hello,Python
        hello,Python
hello,Python
00000000hello,Python
hello,Python
-0008910

④字符串的劈分操作

#从左侧开始劈分
s = 'hello world Python'
s1 = 'hello|world|Python'

print(s.split())
print(s1.split(sep='|'))
print(s1.split(sep='|',maxsplit=1))

print('-------------------------')
#从右侧开始劈分
print(s.rsplit())
print(s1.rsplit('|'))
print(s1.rsplit(sep='|',maxsplit=1))

['hello', 'world', 'Python']
['hello', 'world', 'Python']
['hello', 'world|Python']
-------------------------
['hello', 'world', 'Python']
['hello', 'world', 'Python']
['hello|world', 'Python']

⑤字符串的判断操作

⑥字符串的替换与合并操作

s = 'hello,Python'
print(s.replace('Python','Java'))

s1 = 'hello,Python,Python,Python'
print(s1.replace('Python','Java',2))

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

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

print('*'.join('Python'))

hello,Java
hello,Java,Java,Python
hello|java|Python
hellojavaPython
helloJavaPython
P*y*t*h*o*n

⑦字符串的比较操作

print('apple'>'app')
print('apple'>'banana')
print(ord('a'),ord('b'))
print(chr(97),chr(98))

'''
== 与is的区别
== 比较的是value
is 比较的是id
'''

True
False
97 98
a b

⑧字符串的切片操作

s = 'hello,Python'
s1 = s[:5]  #没有指定起始位置，所以从0开始切
s2 = s[6:]  #没有指定结束位置，所以切到字符串的最后一个元素
s3 = '!'
newstr = s1 + s3 + s2
print(s1)
print(s2)
print(newstr)

print('--------------切片[start:end:step]---------------')
print(s[1:5:1]) #从1开始截到5(不包含5)，步长为1
print(s[::2])
print(s[::-1])  #因为步长为负数，所以默认从字符串的最后一个元素开始，到字符串的第一个元素结束
print(s[-6::1]) #从索引为-6开始，到字符串的最后一个元素结束

hello
Python
hello!Python
--------------切片[start:end:step]---------------
ello
hloPto
nohtyP,olleh
Python

⑨格式化字符串

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

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

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

我叫张三,今年20岁
我叫张三,今年20岁
我叫张三,今年20岁

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

99
3.142
     3.142

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

3.14
3.142
     3.142

⑩字符串的编码与解码

s = '天涯共此时'
#编码
print(s.encode(encoding='GBK')) #在GBK编码格式中，一个中文占两个字节
print(s.encode(encoding='UTF-8')) #在UTF-8编码格式中，一个中文占三个字节
#输出结果前面有个b，代表是二进制

#解码
#byte代表一个二进制数据(字节类型)
byte = s.encode(encoding='GBK') #编码
print(byte.decode(encoding='GBK'))  #解码

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

b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'
天涯共此时
天涯共此时

24、函数

（1）函数的创建和调用

（2）函数的参数传递

（3）函数参数传递的内存分析

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

如果实参是不可变对象，在函数体的修改不会影响实参的值。例如arg1修改为100，不会影响n1的值

如果实参是可变对象，在函数体的修改会影响实参的值。例如arg2的修改，append(10),会影响n2的值（4）函数的返回值

（5）函数的参数定义

'''
def fun(*args1,*args2):
    pass
以上代码会报错，因为个数可变的位置参数只能有1个
'''
'''
def fun1(**args1,**args2):
    pass
以上代码会报错，因为个数可变的关键字参数只能有1个
'''
def fun2(*args1,**args2):
    pass

'''
def fun3(**args1,*args2):
    pass
以上代码会报错,在函数的定义中，若既有个数可变的关键字形参，也有个数可变的位置形参，要求位置形参放在关键字形参之前
'''

（6）函数的参数总结

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

（7）变量的作用域

def fun(a,b):
    c = a + b   #c为局部变量；a、b为函数的形参，作用范围在函数内部，也是局部变量
    print(c)

def fun1():
    global age  #局部变量使用global声明就变成了全局变量
    age = 20
    print(age)

fun1()
print(age)

20
20

（8）递归函数

25、Bug

（1）Bug的常见类型

（2）Python的异常处理机制

（3）Python常见的异常类型

#print(10 / 0)   #ZeroDivisionError

lst = [11,22,33,44]
#print(lst[4])   #IndexError

dic = {'name':'张三','age':20}
#print(dic['gender'])    #KeyError

#print(num)  #NameError

#int a = 20  #SyntaxError

#a = int('hello')    #ValueError

（4）traceback模块的使用

（5）Pycharm开发环境的调试

26、类与对象

（1）定义Python中的类

class Student:
    pass

print(id(Student))
print(type(Student))
print(Student)

2939991260768
<class 'type'>
<class '__main__.Student'>

（2）对象的创建

class Student:
    native_pace = '吉林'
    def __init__(self,name,age):
        self.name = name
        self.age = age

    #实例方法
    def eat(self):
        print('学生在吃饭...')

    #静态方法
    @staticmethod
    def method():
        print('使用静态方法')

    #类方法
    @classmethod
    def cm(cls):
        print('使用类方法')

#创建Student类的对象
stu1 = Student('张三',20)
print(id(stu1))
print(type(stu1))
print(stu1)

stu2 = Student('李四',18)
stu2.eat()  #①对象名.方法名()
print(stu2.name)
print(stu2.age)
print('-----------------')
Student.eat(stu2)   #②类名.方法名(类的对象)，①与②的功能相同，都是调用Student中的eat方法

1987872813936
<class '__main__.Student'>
<__main__.Student object at 0x000001CED673F370>
学生在吃饭...
李四
18
-----------------
学生在吃饭...

（3）类属性、类方法、静态方法

（4）动态绑定属性和方法

27、面向对象的三大特征

（1）封装的实现方式

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

    def show(self):
        print(self.name,self.__age)

stu = Student('张三',20)
stu.show()
#在类外部使用name与age
print(stu.name)
#print(stu.__age)    #AttributeError: 'Student' object has no attribute '__age'，不能访问age
print(dir(stu))
print(stu._Student__age)    #虽然不能直接访问__age，但是在类的外部可以通过 _Student__age 进行访问

张三 20
张三
['_Student__age', '__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__', 'name', 'show']
20

（2）继承及其实现方式

（3）方法重写

（4）Object类

class Student:
    pass

stu = Student()
print(dir(stu))
print(stu)	#默认会调用__str__方法

['__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__']
<__main__.Student object at 0x00000243EBF67520>

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

    def __str__(self):	#对__str__进行重写
        return '我的名字是{0}，今年{1}岁'.format(self.name,self.age)

stu = Student('张三',20)
print(stu)  #默认会调用__str__方法

我的名字是张三，今年20岁

（5）多态及其实现

也就是说，对于上面那个例子，不需要关心Person是谁的子类，只需要关心Person是否有eat方法。（6）特殊属性和特殊方法

①特殊属性

class A:
    pass
class B:
    pass
class C(A,B):
    def  __init__(self,name,age):
        self.name = name
        self.age = age
class D(A):
    pass
#创建C类对象
x = C('Jack',20)    #x是C类型的一个实例对象
print(x.__dict__)   #输出实例对象的属性字典
print(C.__dict__)   #输出类对象的方法和属性字典
print(x.__class__)  #输出对象所属的类
print(C.__bases__)  #输出C类的父类
print(C.__base__)   #输出C类的基类(继承的第一个父类)
print(C.__mro__)    #输出类的层次结构
print(A.__subclasses__())   #用列表形式输出A的子类

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

②特殊方法

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('Jack')
stu2 = Student('李四')
s = stu1 + stu2 #因为在Student类中重写了__add__()方法，所以能实现Student对象的加法运算，若没有重写则会报错
print(s)
s = stu1.__add__(stu2)
print(s)
print('-------------------')
lst = [11,22,33,44]
print(len(lst))
print(lst.__len__())
print(len(stu1))

120
120
Jack李四
Jack李四
-------------------
4
4
4

28、类的赋值、浅拷贝和深拷贝

class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu = cpu;
        self.disk = disk
#变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1,id(cpu1))
print(cpu2,id(cpu2))

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

import copy
computer2 = copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)
print('----------------------')
#深拷贝
computer3 = copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer3,computer3.cpu,computer3.disk)

输出结果：

变量的赋值分析图：

类的浅拷贝分析图：

类的深拷贝分析图：

29、模块

（1）模块的定义

模块一般含有函数、类、语句。（2）自定义模块以及模块的导入

from math import pi	#若以这种方式导入，可以直接使用pi

print(pi)

3.141592653589793

import math	#若以这种方式导入，使用pi需要写math.pi

print(math.pi)

（3）以主程序方式运行程序

例如：

demo1.py

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

print(add(10,20))

demo2.py

import demo1

print(demo1.add(100,200))

运行demo2.py的结果：

30
300

若demo1.py以主程序方式运行：
demo1.py

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

if __name__ == '__main__':	#只有运行demo1时才会执行这句
    print(add(10,20))

demo2.py

import demo1

print(demo1.add(100,200))

运行demo2.py的结果：

300

（4）Python中的包

例如：

module1.py（在package1包中）

a = 10

demo1.py

#在demo1的模块中导入package1包
import package1.module1
print(package1.module1.a)

import package1.module1 as ma   #ma是package1.module1这个模块的别名
print(ma.a)

#导入带有包的模块的注意事项
import package1
import module1
#使用import方式进行导入时，只能跟包名或模块名

from package1 import module1
from package1.module1 import ma
#使用from...import方式可以导入包、模块、函数、变量

（5）Python中常用的内置模块

（6）第三方模块的安装及使用

30、文件

（1）编码格式的介绍

（2）文件的读写

（3）常用的文件打开模式

例如，对于打开模式 ’ b '，可以如下所示使用：

src_file = open('logo.png','rb')

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

target_file.write(src_file.read())

target_file.close()

src_file.close()

（4）文件对象的常用方法

（5）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 = MyContentMgr()
    file.show()

enter方法被调用了
show方法被调用执行了
exit方法被调用执行了

即使出现错误，最后也能释放资源：

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方法被调用执行了',1/0)

with MyContentMgr() as file:    #相当于file = MyContentMgr()
    file.show()

enter方法被调用了
exit方法被调用执行了
Traceback (most recent call last):
  File "D:/PyCharm Community Edition 2020.2.2/Project/venv/Include/demo1.py", line 13, in <module>
    file.show()
  File "D:/PyCharm Community Edition 2020.2.2/Project/venv/Include/demo1.py", line 10, in show
    print('show方法被调用执行了',1/0)
ZeroDivisionError: division by zero

有了with语句，第（3）点中的程序可以改为：

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

31、目录操作

（1）os模块常用的函数

例如：

import os
os.system('notepad.exe')
os.system('calc.exe')
#直接调用可执行文件
os.startfile('C:\\Program Files\\Tencent\\QQ\\Bin\\qq.exe')

（2）os.path模块的常用方法