输入输出
输出sep 输入
# inout 输入类型为str
a = int(input("请输入一个int类型数n"))
print(a + 1)
#逻辑
ifif语句没有{}只有缩进
# inout 输入类型为str
a = int(input("请输入一个年龄n"))
if a > 18:
print('已经成年')
else:
print(' 未成年')
逻辑运算符
Python 逻辑运算符用于操作 bool 类型的表达式，执行结果也是 bool 类型，这两点其实都是错误的！
Python 逻辑运算符可以用来操作任何类型的表达式，不管表达式是不是 bool 类型；同时，逻辑运算的结果也不一定是 bool 类型，它也可以是任意类型。请看下面的例子：
print(100 and 200)
print(45 and 0)
print("" or "http://c.biancheng.net/python/")
print(18.5 or "http://c.biancheng.net/python/")
运行结果：
200
0
http://c.biancheng.net/python/
18.5
你看，本例中 and 和 or 运算符操作的都不是 bool 类型表达式，操作的结果也不是 bool 值。
逻辑运算符的本质在 Python 中，and 和 or 不一定会计算右边表达式的值，有时候只计算左边表达式的值就能得到最终结果。
另外，and 和 or 运算符会将其中一个表达式的值作为最终结果，而不是将 True 或者 False 作为最终结果。
对于 and 运算符，两边的值都为真时最终结果才为真，但是只要其中有一个值为假，那么最终结果就是假，所以 Python 按照下面的规则执行 and 运算：
如果左边表达式的值为假，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是假，此时 and 会把左边表达式的值作为最终结果。如果左边表达式的值为真，那么最终值是不能确定的，and 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。
对于 or 运算符，情况是类似的，两边的值都为假时最终结果才为假，只要其中有一个值为真，那么最终结果就是真，所以 Python 按照下面的规则执行 or 运算：
如果左边表达式的值为真，那么就不用计算右边表达式的值了，因为不管右边表达式的值是什么，都不会影响最终结果，最终结果都是真，此时 or 会把左边表达式的值作为最终结果。如果左边表达式的值为假，那么最终值是不能确定的，or 会继续计算右边表达式的值，并将右边表达式的值作为最终结果。
使用代码验证上面的结论：
url = "http://c.biancheng.net/cplus/"
print("----False and xxx-----")
print( False and print(url) )
print("----True and xxx-----")
print( True and print(url) )
print("----False or xxx-----")
print( False or print(url) )
print("----True or xxx-----")
print( True or print(url) )
运行结果：
----False and xxx-----
False
----True and xxx-----
http://c.biancheng.net/cplus/
None
----False or xxx-----
http://c.biancheng.net/cplus/
None
----True or xxx-----
True
第 4 行代码中，and 左边的值为假，不需要再执行右边的表达式了，所以 print(url) 没有任何输出。
第 6 行代码中，and 左边的值为真，还需要执行右边的表达式才能得到最终的结果，所以 print(url) 输出了一个网址。
第 8、10 行代码也是类似的。
for 运算符 / 和 // 除法运算符从运行结果可以发现：
/的计算结果总是小数，不管是否能除尽，也不管参与运算的是整数还是小数。当有小数参与运算时，//结果才是小数，否则就是整数。
需要注意的是，除数始终不能为 0，除以 0 是没有意义的，这将导致 ZeroDivisionError 错误。在某些编程语言中，除以 0 的结果是无穷大（包括正无穷大和负无穷大）。
乘法运算符乘法运算也和数学中的规则相同，请看代码：
n = 4 * 25f = 34.5 * 2 print(n, ",", f)
运行结果：
100 , 69.0
*除了可以用作乘法运算，还可以用来重复字符串，也即将 n 个同样的字符串连接起来，请看代码：
str1 = "hello " print(str1 * 4)
% 求余运算符运行结果：
hello hello hello hello
Python % 运算符用来求得两个数相除的余数，包括整数和小数。Python 使用第一个数字除以第二个数字，得到一个整数的商，剩下的值就是余数。对于小数，求余的结果一般也是小数。
注意，求余运算的本质是除法运算，所以第二个数字也不能是 0，否则会导致 ZeroDivisionError 错误。
Python % 使用示例：
print("-----整数求余-----")
print("15%6 =", 15%6)
print("-15%6 =", -15%6)
print("15%-6 =", 15%-6)
print("-15%-6 =", -15%-6)
print("-----小数求余-----")
print("7.7%2.2 =", 7.7%2.2)
print("-7.7%2.2 =", -7.7%2.2)
print("7.7%-2.2 =", 7.7%-2.2)
print("-7.7%-2.2 =", -7.7%-2.2)
print("---整数和小数运算---")
print("23.5%6 =", 23.5%6)
print("23%6.5 =", 23%6.5)
print("23.5%-6 =", 23.5%-6)
print("-23%6.5 =", -23%6.5)
print("-23%-6.5 =", -23%-6.5)
运行结果：
-----整数求余-----
15%6 = 3
-15%6 = 3
15%-6 = -3
-15%-6 = -3
-----小数求余-----
7.7%2.2 = 1.0999999999999996
-7.7%2.2 = 1.1000000000000005
7.7%-2.2 = -1.1000000000000005
-7.7%-2.2 = -1.0999999999999996
—整数和小数运算—
23.5%6 = 5.5
23%6.5 = 3.5
23.5%-6 = -0.5
-23%6.5 = 3.0
-23%-6.5 = -3.5
从运行结果可以发现两点：
只有当第二个数字是负数时，求余的结果才是负数。换句话说，求余结果的正负和第一个数字没有关系，只由第二个数字决定。%两边的数字都是整数时，求余的结果也是整数；但是只要有一个数字是小数，求余的结果就是小数。 次方（乘方）运算符
Python ** 运算符用来求一个 x 的 y 次方，也即次方（乘方）运算符。
由于开方是次方的逆运算，所以也可以使用 ** 运算符间接地实现开方运算。
Python ** 运算符示例：
print('----次方运算----')
print('3**4 =', 3**4)
print('2**5 =', 2**5)
print('----开方运算----')
print('81**(1/4) =', 81**(1/4))
print('32**(1/5) =', 32**(1/5))
<<左移运算符运行结果：
----次方运算----
34 = 81
25 = 32
----开方运算----
81**(1/4) = 3.0
32**(1/5) = 2.0
Python 左移运算符<<用来把操作数的各个二进制位全部左移若干位，高位丢弃，低位补 0。
例如，9<<3可以转换为如下的运算：
<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储） ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000 （72 在内存中的存储）
所以9<<3的结果为 72。
又如，(-9)<<3可以转换为如下的运算：
<< 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储） ----------------------------------------------------------------------------------- 1111 1111 -- 1111 1111 -- 1111 1111 -- 1011 1000 （-72 在内存中的存储）
所以(-9)<<3的结果为 -72
如果数据较小，被丢弃的高位不包含 1，那么左移 n 位相当于乘以 2 的 n 次方。
使用 Python 代码对上面的分析进行验证：
print("%X" % (9<<3) )
print("%X" % ((-9)<<3) )
>>右移运算符运行结果：
48
-48
Python 右移运算符>>用来把操作数的各个二进制位全部右移若干位，低位丢弃，高位补 0 或 1。如果数据的最高位是 0，那么就补 0；如果最高位是 1，那么就补 1。
例如，9>>3可以转换为如下的运算：
>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在内存中的存储） ----------------------------------------------------------------------------------- 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 （1 在内存中的存储）
所以9>>3的结果为 1。
又如，(-9)>>3可以转换为如下的运算：
>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在内存中的存储） ----------------------------------------------------------------------------------- 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110 （-2 在内存中的存储）
所以(-9)>>3的结果为 -2
如果被丢弃的低位不包含 1，那么右移 n 位相当于除以 2 的 n 次方（但被移除的位中经常会包含 1）。
使用 Python 代码对上面的分析进行验证：
print("%X" % (9>>3) )
print("%X" % ((-9)>>3) )
随机数运行结果：
1
-2
import random # 产生随机数 num = random.randint(1, 3) print(num)三目运算符
但是 Python 提供了一种更加简洁的写法，如下所示：
max = a if a>b else b
这是一种类似于其它编程语言中三目运算符? :的写法。Python 是一种极简主义的编程语言，它没有引入? :这个新的运算符，而是使用已有的 if else 关键字来实现相同的功能。
使用 if else 实现三目运算符（条件运算符）的格式如下：
exp1 if contion else exp2
condition 是判断条件，exp1 和 exp2 是两个表达式。如果 condition 成立（结果为真），就执行 exp1，并把 exp1 的结果作为整个表达式的结果；如果 condition 不成立（结果为假），就执行 exp2，并把 exp2 的结果作为整个表达式的结果。
前面的语句max = a if a>b else b的含义是：
如果 a>b 成立，就把 a 作为整个表达式的值，并赋给变量 max；如果 a> b 不成立，就把 b 作为整个表达式的值，并赋给变量 max。 三目运算符的嵌套
Python 三目运算符支持嵌套，如此可以构成更加复杂的表达式。在嵌套时需要注意 if 和 else 的配对，例如：
a if a>b else c if c>d else d
应该理解为：
a if a>b else ( c if c>d else d )
【实例】使用 Python 三目运算符判断两个数字的关系：
a = int( input("Input a: ") )
b = int( input("Input b: ") )
print("a大于b") if a>b else ( print("a小于b") if a
可能的运行结果：
Input a: 45↙
Input b: 100↙
a小于b
该程序是一个嵌套的三目运算符。程序先对 a>b 求值，如果该表达式为 True，程序就返回执行第一个表达式 print(“a大于b”)，否则将继续执行 else 后面的内容，也就是：
( print(“a小于b”) if a
进入该表达式后，先判断 a
字符串
字符串查找
# find()查找字符串中是否存在某个字符串
# my_str.find(sub: start: end:)
# sub:查询的字符串 类型str
# start 开始查找的位置 默认为0
# end 结束的位置，查找到哪里结束 默认len()
# 返回值如果查到为 正数下标
# 没有查到为-1
my_str = 'hello world itcast and itcastcpp'
index = my_str.find('hello')
print(index) # 0
print(my_str.find('itcast')) # 12
print(my_str.find('itcast', 15)) # 23
#rfind() right find() 字符串后面查找还是先找i
print(my_str.rfind('itcast', 15)) # 23
替换
replace（,1）1次
字符串连接 join
字符串分割 split （不包含切割的）
其他方法
capitalize（）第一个首字母大写
title（）首字母全部大写
upper（）全部大写
lower（）全部小写
isalpha 是否全为字母，true false
isdigit 只包含数字
isalnum 只包含字母或者数字
isspace 只包含空格
startswith（hello）以hello开头 返回true
endswith（hello）以hello结尾 返回true
ljust （width）左对齐 以空格填充到width
rjust 右对齐
center 居中对齐
lstrip 删除左边空白
rstrip 删除右边空白
strip 删除两边空白 不能去除中间空白 使用replace（“ ”，“” ）替换
partition（’my‘ ） 分为前中后 中间是my
列表、元组、字典、集合
序列
序列索引
序列中，每个元素都有属于自己的编号（索引）。从起始元素开始，索引值从 0 开始递增，如图 1 所示。
图 1 序列索引值示意图
除此之外，Python 还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始，如图 2 所示。
图 2 负值索引示意图
序列切片
切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素，通过切片操作，可以生成一个新的序列。
序列实现切片操作的语法格式如下：
sname[start : end : step]
其中，各个参数的含义分别是：
sname：表示序列的名称；start：表示切片的开始索引位置（包括该位置），此参数也可以不指定，会默认为 0，也就是从序列的开头进行切片；end：表示切片的结束索引位置（不包括该位置），如果不指定，则默认为序列的长度；step：表示在切片过程中，隔几个存储位置（包含当前位置）取一次元素，也就是说，如果 step 的值大于 1，则在进行切片去序列元素时，会“跳跃式”的取元素。如果省略设置 step 的值，则最后一个冒号就可以省略。
例如，对字符串“C语言中文网”进行切片：
str="C语言中文网"#取索引区间为[0,2]之间（不包括索引2处的字符）的字符串
print(str[:2])
#隔 1 个字符取一个字符，区间是整个字符串
print(str[::2])
#取整个字符串，此时 [] 中只需一个冒号即可
print(str[:])
运行结果为：
C语
C言文
C语言中文网
序列相加
Python 中，支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。
这里所说的“类型相同”，指的是“+”运算符的两侧序列要么都是列表类型，要么都是元组类型，要么都是字符串。
例如，前面章节中我们已经实现用“+”运算符连接 2 个（甚至多个）字符串，如下所示：
str="c.biancheng.net"
print("C语言"+"中文网:"+str)
输出结果为：
C语言中文网：c.biancheng.net
序列相乘
Python 中，使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果。例如：
str="C语言中文网"
print(str*3)
输出结果为：
‘C语言中文网C语言中文网C语言中文网’
和序列相关的内置函数
Python提供了几个内置函数（表 3 所示），可用于实现与序列相关的一些常用操作。
| 函数 | 功能 |
|---|---|
| len() | 计算序列的长度，即返回序列中包含多少个元素。 |
| max() | 找出序列中的最大元素。注意，对序列使用 sum() 函数时，做加和操作的必须都是数字，不能是字符或字符串，否则该函数将抛出异常，因为解释器无法判定是要做连接操作（+ 运算符可以连接两个序列），还是做加和操作。 |
| min() | 找出序列中的最小元素。 |
| list() | 将序列转换为列表。 |
| str() | 将序列转换为字符串。 |
| sum() | 计算元素和。 |
| sorted() | 对元素进行排序。 |
| reversed() | 反向序列中的元素。 |
| enumerate() | 将序列组合为一个索引序列，多用在 for 循环中。 |
这里给大家给几个例子：
str="c.biancheng.net" #找出最大的字符 print(max(str)) #找出最小的字符 print(min(str)) #对字符串中的元素进行排序 print(sorted(str))
list（列表） 创建list输出结果为：
t
.
[’.’, ‘.’, ‘a’, ‘b’, ‘c’, ‘c’, ‘e’, ‘e’, ‘g’, ‘h’, ‘i’, ‘n’, ‘n’, ‘n’, ‘t’]
创建列表的方法可分为两种，下面分别进行介绍。
1) 使用 [ ] 直接创建列表使用[ ]创建列表后，一般使用=将它赋值给某个变量，具体格式如下：
listname = [element1 , element2 , element3 , … , elementn]
其中，listname 表示变量名，element1 ~ elementn 表示列表元素。
例如，下面定义的列表都是合法的：
num = [1, 2, 3, 4, 5, 6, 7] name = ["C语言中文网", "http://c.biancheng.net"] program = ["C语言", "Python", "Java"]
另外，使用此方式创建列表时，列表中元素可以有多个，也可以一个都没有，例如：
emptylist = [ ]
这表明，emptylist 是一个空列表。
2) 使用 list() 函数创建列表除了使用[ ]创建列表外，Python 还提供了一个内置的函数 list()，使用它可以将其它数据类型转换为列表类型。例如：
#将字符串转换成列表
list1 = list("hello")
print(list1) # ['h', 'e', 'l', 'l', 'o']
#将元组转换成列表
tuple1 = ('Python', 'Java', 'C++', 'Javascript')
list2 = list(tuple1)
print(list2)#将字典转换成列表 ['Python', 'Java', 'C++', 'Javascript']
dict1 = {'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3) # ['a', 'b', 'c']
#将区间转换成列表
range1 = range(1, 6)
list4 = list(range1)
print(list4) # [1, 2, 3, 4, 5]
#创建空列表
print(list()) # []
切片拷贝
添加元素list 8=list 6与list 7 =list[:]
区别
前者只是重新给列表起一个名字
后者新建一个列表
- 直接+
相当于在第一个列表的末尾添加了另一个列表。
append（） 视为整体
extend（） 逐个添加
extend() 和 append() 的不同之处在于：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。
- insert() 任意位置
删除元素list.insert(index , obj)
其中，index 表示指定位置的索引值。insert() 会将 obj 插入到 列表第 index 个元素的位置。
del 也可以删除中间一段连续的元素，格式为：
del listname[start : end] del listname[index]
其中，start 表示起始索引，end 表示结束索引。del 会删除从索引 start 到 end 之间的元素，不包括 end 位置的元素。
pop() 方法用来删除列表中指定索引处的元素，具体格式如下：
listname.pop(index)
其中，listname 表示列表名称，index 表示索引值。如果不写 index 参数，默认会删除列表中的最后一个元素，类似于数据结构中的“出栈”操作。 返回删除的内容
remove()：根据元素值进行删除
该方法会根据元素本身的值来进行删除操作。
需要注意的是，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。
clear()：删除列表所有元素
clear() 用来删除列表的所有元素，也即清空列表，请看下面的代码：
url = list("http://c.biancheng.net/python/")
url.clear()
print(url)
修改
修改单个元素
修改单个元素非常简单，直接对元素赋值即可。请看下面的例子：
nums = [40, 36, 89, 2, 36, 100, 7] nums[2] = -26 #使用正数索引nums[-3] = -66.2 #使用负数索引print(nums)
运行结果：
[40, 36, -26, 2, -66.2, 100, 7]
使用索引得到列表元素后，通过=赋值就改变了元素的值。
修改一组元素
nums = [40, 36, 89, 2, 36, 100, 7] #修改第 1~4 个元素的值（不包括第4个元素） nums[1: 4] = [45.25, -77, -52.5] print(nums)
运行结果：
[40, 45.25, -77, -52.5, 36, 100, 7]
如果对空切片（slice）赋值，就相当于插入一组新的元素：
nums = [40, 36, 89, 2, 36, 100, 7] #在4个位置插入元素 nums[4: 4] = [-77, -52.5, 999] print(nums)
运行结果：
[40, 36, 89, 2, -77, -52.5, 999, 36, 100, 7]
使用切片语法赋值时，Python 不支持单个值，例如下面的写法就是错误的：
nums[4: 4] = -77
但是如果使用字符串赋值，Python 会自动把字符串转换成序列，其中的每个字符都是一个元素，请看下面的代码：
s = list("Hello")
s[2:4] = "XYZ"
print(s)
运行结果：
[‘H’, ‘e’, ‘X’, ‘Y’, ‘Z’, ‘o’]
使用切片语法时也可以指定步长（step 参数），但这个时候就要求所赋值的新元素的个数与原有元素的个数相同，例如：
nums = [40, 36, 89, 2, 36, 100, 7] #步长为2，为第1、3、5个元素赋值 nums[1: 6: 2] = [0.025, -99, 20.5] print(nums)
查找运行结果：
[40, 0.025, 89, -99, 36, 20.5, 7]
index() 方法
listname.index(obj, start, end) 根据数据值，查找下标，没有程序报错
count()方法
count() 方法用来统计某个元素在列表中出现的次数，基本语法格式为：
listname.count(obj)
listname 代表列表名，obj 表示要统计的元素。 true = 1 false=0
in/not in
排序存在为true 不存在为false 3.14 in my_list 一般和if一起使用
sort（） 默认从小到大排序
.sort（reverse=True） 从大到小排序
my_list1=sorted（my_list ，reverse=True） 新列表，从大到小排序
列表中有字典
list1 = [{'name': 'd', 'age': 19},
{'name': 'b', 'age': 16},
{'name': 'a', 'age': 16},
{'name': 'c', 'age': 20}]
list1.sort(key=lambda x: x['name'])
# list1.sort(key=lambda x: (x['name'], x['age'])) 先名字在年龄
print(list1)
list1.sort(key=lambda x: x['age'])
print(list1)
遍历
逆置
切片 [：：-1]创建新列表reverse（） 原列表直接逆置 列表推导式
元组元组的所有元素都放在一对小括号( )中，相邻元素之间用逗号,分隔，
元组和列表（list）的不同之处在于：
列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。 创建
使用 ( ) 直接创建
通过( )创建元组后，一般使用=将它赋值给某个变量，具体格式为：
tuplename = (element1, element2, …, elementn)
- 使用tuple()函数创建元组
除了使用( )创建元组外，Python 还提供了一个内置的函数 tuple()，用来将其它数据类型转换为元组类型。tuple() 的语法格式如下：
tuple(data)
其中，data 表示可以转化为元组的数据，包括字符串、元组、range 对象等。
tuple() 使用示例：
#将字符串转换成元组
tup1 = tuple("hello")print(tup1)
#将列表转换成元组
list1 = ['Python', 'Java', 'C++', 'Javascript']
tup2 = tuple(list1)print(tup2)
#将字典转换成元组
dict1 = {'a':100, 'b':42, 'c':9}
tup3 = tuple(dict1)print(tup3)
#将区间转换成元组
range1 = range(1, 6)
tup4 = tuple(range1)
print(tup4)
#创建空元组
print(tuple())
访问运行结果为：
(‘h’, ‘e’, ‘l’, ‘l’, ‘o’)
(‘Python’, ‘Java’, ‘C++’, ‘Javascript’)
(‘a’, ‘b’, ‘c’)
(1, 2, 3, 4, 5)
()
和列表一样，我们可以使用索引（Index）访问元组中的某个元素（得到的是一个元素的值），也可以使用切片访问元组中的一组元素（得到的是一个新的子元组）。
使用索引访问元组元素的格式为：
tuplename[i]
其中，tuplename 表示元组名字，i 表示索引值。元组的索引可以是正数，也可以是负数。
使用切片访问元组元素的格式为：
tuplename[start : end : step]
其中，start 表示起始索引，end 表示结束索引，step 表示步长。
修改元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组。
例如，对元组变量进行重新赋值：
tup = (100, 0.5, -36, 73)print(tup)
#对元组进行重新赋值
tup = ('Shell脚本',"http://c.biancheng.net/shell/")
print(tup)
运行结果为：
(100, 0.5, -36, 73)
(‘Shell脚本’, ‘http://c.biancheng.net/shell/’)
另外，还可以通过连接多个元组（使用+可以拼接元组）的方式向元组中添加新元素，例如：
tup1 = (100, 0.5, -36, 73) tup2 = (3+12j, -54.6, 99) print(tup1+tup2) print(tup1) print(tup2)
运行结果为：
(100, 0.5, -36, 73, (3+12j), -54.6, 99)
(100, 0.5, -36, 73)
((3+12j), -54.6, 99)
使用+拼接元组以后，tup1 和 tup2 的内容没法发生改变，这说明生成的是一个新的元组。
删除del tup
字典创建字典的方式有很多，下面一一做介绍。
- 使用 { } 创建字典
由于字典中每个元素都包含两部分，分别是键（key）和值（value），因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。
使用{ }创建字典的语法格式如下：
dictname = {‘key’:‘value1’, ‘key2’:‘value2’, …, ‘keyn’:valuen}
其中 dictname 表示字典变量名，keyn : valuen 表示各个元素的键值对。需要注意的是，同一字典中的各个键必须唯一，不能重复。
如下代码示范了使用花括号语法创建字典：
#使用字符串作为key
scores = {'数学': 95, '英语': 92, '语文': 84}
print(scores)
#使用元组和数字作为key
dict1 = {(20, 30): 'great', 、0}
print(dict1)
#创建空元组
dict2 = {}
print(dict2)
运行结果为：
{‘数学’: 95, ‘英语’: 92, ‘语文’: 84}
{(20, 30): ‘great’, 30: [1, 2, 3]}
{}
可以看到，字典的键可以是整数、字符串或者元组，只要符合唯一和不可变的特性就行；字典的值可以是 Python 支持的任意数据类型。
- 通过 fromkeys() 方法创建字典
使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典，具体格式为：
dictname = dict.fromkeys(list，value=None)
其中，list 参数表示字典中所有键的列表（list）；value 参数表示默认值，如果不写，则为空值 None。
请看下面的例子：
knowledge = ['语文', '数学', '英语'] scores = dict.fromkeys(knowledge, 60) print(scores)
运行结果为：{‘语文’: 60, ‘英语’: 60, ‘数学’: 60}
可以看到，knowledge 列表中的元素全部作为了 scores 字典的键，而各个键对应的值都是 60。这种创建方式通常用于初始化字典，设置 value 的默认值。
- 通过 dict() 映射函数创建字典
通过 dict() 函数创建字典的写法有多种，表 2 罗列出了常用的几种方式，它们创建的都是同一个字典 a。
| 创建格式 | 注意事项 |
|---|---|
| a = dict(str1=value1, str2=value2, str3=value3) | str 表示字符串类型的键，value 表示键对应的值。使用此方式创建字典时，字符串不能带引号。 |
| #方式1 demo = [(‘two’,2), (‘one’,1), (‘three’,3)] #方式2 demo = [[‘two’,2], [‘one’,1], [‘three’,3]] #方式3 demo = ((‘two’,2), (‘one’,1), (‘three’,3)) #方式4 demo = ([‘two’,2], [‘one’,1], [‘three’,3]) a = dict(demo) | 向 dict() 函数传入列表或元组，而它们中的元素又各自是包含 2 个元素的列表或元组，其中第一个元素作为键，第二个元素作为值。 |
| keys = [‘one’, ‘two’, ‘three’] #还可以是字符串或元组 values = [1, 2, 3] #还可以是字符串或元组 a = dict( zip(keys, values) ) | 通过应用 dict() 函数和 zip() 函数，可将前两个列表转换为对应的字典。 |
注意，无论采用以上哪种方式创建字典，字典中各元素的键都只能是字符串、元组或数字，不能是列表。列表是可变的，不能作为键（key）。
如果不为 dict() 函数传入任何参数，则代表创建一个空的字典，例如：
# 创建空的字典d = dict() print(d)
访问字典运行结果为：{}
列表和元组是通过下标来访问元素的，而字典不同，它通过键来访问对应的值。因为字典中的元素是无序的，每个元素的位置都不固定，所以字典也不能像列表和元组那样，采用切片的方式一次性访问多个元素。
Python 访问字典元素的具体格式为：
dictname[key]
其中，dictname 表示字典变量的名字，key 表示键名。注意，键必须是存在的，否则会抛出异常。
请看下面的例子：
tup = (['two',26], ['one',88], ['three',100], ['four',-59])dic = dict(tup) print(dic['one']) #键存在 print(dic['five']) #键不存在
运行结果：
88
Traceback (most recent call last):
File “C:UsersmozhiyanDesktopdemo.py”, line 4, in
print(dic[‘five’]) #键不存在
KeyError: ‘five’
除了上面这种方式外，Python 更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时，get() 方法不会抛出异常。
get() 方法的语法格式为：
dictname.get(key[,default])
其中，dictname 表示字典变量的名字；key 表示指定的键；default 用于指定要查询的键不存在时，此方法返回的默认值，如果不手动指定，会返回 None。
get() 使用示例：
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('one') )
运行结果：88
注意，当键不存在时，get() 返回空值 None，如果想明确地提示用户该键不存在，那么可以手动设置 get() 的第二个参数，例如：
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('five', '该键不存在') )
删除字典运行结果：该键不存在
和删除列表、元组一样，手动删除字典也可以使用 del 关键字，例如：
a = dict(two=0.65, one=88, three=100, four=-59) print(a) del a print(a)添加键值
为字典添加新的键值对很简单，直接给不存在的 key 赋值即可，具体语法格式如下：
dictname[key] = value
对各个部分的说明：
dictname 表示字典名称。key 表示新的键。value 表示新的值，只要是 Python 支持的数据类型都可以。如果key存在就是修改key值不存在就是添加
下面代码演示了在现有字典基础上添加新元素的过程：
a = {'数学':95}
print(a)
#添加新键值对
a['语文'] = 89
print(a)
#再次添加新键值对
a['英语'] = 90
print(a)
修改键值对运行结果：
{‘数学’: 95}
{‘数学’: 95, ‘语文’: 89}
{‘数学’: 95, ‘语文’: 89, ‘英语’: 90}
Python 字典中键（key）的名字不能被修改，我们只能修改值（value）。
字典中各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，那么键所对应的值就会被新的值替换掉，以此达到修改元素值的目的。请看下面的代码：
a = {'数学': 95, '语文': 89, '英语': 90}
print(a)
a['语文'] = 100
print(a)
运行结果：
{‘数学’: 95, ‘语文’: 89, ‘英语’: 90}
{‘数学’: 95, ‘语文’: 100, ‘英语’: 90}
可以看到，字典中没有再添加一个{'语文':100}键值对，而是对原有键值对{'语文': 89}中的 value 做了修改。
删除键值对del
# 使用del语句删除键值对
a = {'数学': 95, '语文': 89, '英语': 90}
del a['语文']
del a['数学']
print(a)
运行结果为：{‘英语’: 90}
.pop（key）
返回的是删除的value值
###判断字典中是否存在指定键值对
如果要判断字典中是否存在指定键值对，首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键，可以使用 in 或 not in 运算符。
需要指出的是，对于 dict 而言，in 或 not in 运算符都是基于 key 来判断的。
例如如下代码：
a = {'数学': 95, '语文': 89, '英语': 90}
# 判断 a 中是否包含名为'数学'的key
print('数学' in a) # True
# 判断 a 是否包含名为'物理'的key
print('物理' in a) # False
运行结果为：
True
False
通过 in（或 not in）运算符，我们可以很轻易地判断出现有字典中是否包含某个键，如果存在，由于通过键可以很轻易的获取对应的值，因此很容易就能判断出字典中是否有指定的键值对。
遍历for key in my_dict print (key, my_dicr[key])
- .keys() 返回所有的key.values（）返回所有键对应的值items() 用于返回字典中所有的键值对（key-value）
使用list()进行类型转换，转换为列表类型
a = {'数学': 95, '语文': 89, '英语': 90}
b = list(a.keys())
print(b)
使用for循环遍历
result = my_dict.keys()
print(result,type(result))
for key in result:
print(key)
for k,v in my_dict.items():
print(k,v)
. enemerate（）将可迭代序列中元素所在的下标和具体的元素数据组合在一起
for i in my_list:
print(my_list.index(i),i )
for j in enumeratr(my_list):
print(j)
函数
# 函数
def print_info():
print("hello word!")
# 函数调用
print_info()
if age < 12 :
print("婴幼儿")
elif age >= 12 and age < 18:
print("青少年")
elif age >= 18 and age < 30:
print("成年人")
elif age >= 30 and age < 50:
pass
文档空语句 pass。pass 是 Python 中的关键字，用来让解释器跳过此处，什么都不做。
# 函数
def fun():
"""
打印输出
"""
print("hello word!")
# 函数调用
fun()
# 文档说明 不能加（）
help(fun)
变量
局部变量 在全局不能使用
全局变量
在局部变量里修改全局变量
returnglobal 变量名
变量名 = 修改的值
返回数据终止程序
#多个参数 return [a,b]参数
def func(a, b, c):
print(f"a:{a}")
print(f"b:{b}")
print(f"c:{c}")
# 位置传参，按照形参的位置顺序将实参的值传递给形参
func(1, 2, 3)
# func(3, 1, 2)
# 关键字传参，指定实参给到哪个形参，注意点：关键字必须是函数的形参名
func(a=10, b=20, c=30)
# func(c=10, a=20, b=30
# 混合使用，先写位置传参，再写关键字传参
# func(10, b=20, c=30)
# func(a=10, 20, 30) # 代码会报错
# func(10, a=30, b=20) # 代码报错
缺省参数
Python 定义带有默认值参数的函数，其语法格式如下：
def 函数名(…，形参名，形参名=默认值)：
代码块
注意，在使用此格式定义函数时，指定有默认值的形式参数必须在所有没默认值参数的最后，否则会产生语法错误。
不定长参数args和kwargs可以为任意值
# 在形参前加入一个*，该形参变为不定长元组形参，可以接收所有位置的位置实参，类型是元组
# 在形参前加入两个*，该形参变为不定长字典形参，可以接收所有的关键字实参，类型是字典
def func(*args, **kwargs):
print(args, kwargs)
func(1, 2, 3) # (1, 2, 3) {}
func(a=1, b=2, c=3) # (){'a': 1, 'b': 2, 'c': 3}
func(1, 2, 3, a=1, b=2, c=3) # (1, 2, 3) {'a': 1, 'b': 2, 'c': 3}
遍历
def func(*args, **kwargs):
num = 0
# 遍历元组
for i in args:
num = num + i
for j in kwargs.values():
num = num + j
print(num)
func(1, 2, 3, a=1, b=2, c=3)
函数形参的完整形式
普通形参--不定长元组形参--缺省形参（默认值）--不定长字典形参
学生管理系统 初品stu_list = []
def print_menu():
print('-' * 30)
print('1.添加学生')
print('2.删除学生')
print('3.修改学生信息')
print('4.查询单个学生信息')
print('5.查询所有学生')
print('6.退出系统')
print('7.查看菜单')
def select_all_stu():
if len(stu_list):
for student in stu_list:
print(f"姓名为：{student['name']}，年龄为：{student['age']}，成绩为：{student['gender']}")
else:
print("暂时没有学生信息")
print("请添加学生信息")
print("-" * 10)
def add_stu():
"""
添加学生信息
:return:
"""
name = input("姓名：")
for stu in stu_list:
if stu['name'] == name:
print("该学生信息已存在，请重新添加")
return
age = int(input("年龄："))
gender = int(input("成绩："))
stu_dict = {'name': name, 'age': age, 'gender': gender}
stu_list.append(stu_dict)
print("学生信息已经添加成功")
def delete_stu():
"""
删除学生信息
:return:
"""
name = input("请输入要删除的学生的姓名n")
# 查询是否有学生 [{}{}]
if len(stu_list):
# 遍历学生
for stu in stu_list:
if stu['name'] == name:
stu_list.remove(stu)
print(f"学生{name}已删除成功")
else:
print("没有该学生的信息")
else:
print("请添加学生信息")
def update_stu():
"""
根据学生姓名修改学生信息
:return:
"""
name = input("请输入要修改的学生的姓名n")
# 查询是否有学生 [{}{}]
if len(stu_list):
# 遍历学生
for stu in stu_list:
if stu['name'] == name:
stu['age'] = input("请输入的修改年龄：n")
stu['gender'] = input("请输入的成绩n")
print(f"学生{name}已修改成功")
else:
print("没有该学生的信息")
else:
print("请添加学生信息")
def select_stu():
"""
查询单个学生信息
:return:
"""
name = input("请输入要查询的学生的姓名n")
# 查询是否有学生 [{}{}]
if len(stu_list):
# 遍历学生
for stu in stu_list:
if stu['name'] == name:
print(f"姓名为：{stu['name']}，年龄为：{stu['age']}，成绩为：{stu['gender']}")
else:
print("没有该学生的信息")
else:
print("请添加学生信息")
def menu():
while True:
opt = input("--------请您输入操作--------n")
if opt == "1":
print("1.添加学生")
add_stu()
elif opt == "2":
print('2.删除学生')
delete_stu()
elif opt == "3":
print('3.修改学生信息')
update_stu()
elif opt == "4":
print('4.查询单个学生信息')
select_stu()
elif opt == "5":
print('5.查询所有学生')
select_all_stu()
elif opt == '6':
print('欢迎您下次登录')
break
elif opt == "7":
print('查看菜单')
print_menu()
else:
print("输入错误请重新输入.....")
continue
menu()
def a():
print_menu()
menu()
a()
中品（文件读取）
stu_list = []
def print_menu():
print('-' * 30)
print('1.添加学生')
print('2.删除学生')
print('3.修改学生信息')
print('4.查询单个学生信息')
print('5.查询所有学生')
print('6.退出系统')
print('7.查看菜单')
def select_all_stu():
if len(stu_list):
for student in stu_list:
print(f"姓名为：{student['name']}，年龄为：{student['age']}，成绩为：{student['gender']}")
else:
print("暂时没有学生信息")
print("请添加学生信息")
print("-" * 10)
def add_stu():
"""
添加学生信息
:return:
"""
name = input("姓名：")
for stu in stu_list:
if stu['name'] == name:
print("该学生信息已存在，请重新添加")
return
age = int(input("年龄："))
gender = int(input("成绩："))
stu_dict = {'name': name, 'age': age, 'gender': gender}
stu_list.append(stu_dict)
print("学生信息已经添加成功")
def delete_stu():
"""
删除学生信息
:return:
"""
name = input("请输入要删除的学生的姓名n")
# 查询是否有学生 [{}{}]
if len(stu_list):
# 遍历学生
for stu in stu_list:
if stu['name'] == name:
stu_list.remove(stu)
print(f"学生{name}已删除成功")
else:
print("没有该学生的信息")
else:
print("请添加学生信息")
def update_stu():
"""
根据学生姓名修改学生信息
:return:
"""
name = input("请输入要修改的学生的姓名n")
# 查询是否有学生 [{}{}]
if len(stu_list):
# 遍历学生
for stu in stu_list:
if stu['name'] == name:
stu['age'] = input("请输入的修改年龄：n")
stu['gender'] = input("请输入的成绩n")
print(f"学生{name}已修改成功")
else:
print("没有该学生的信息")
else:
print("请添加学生信息")
def select_stu():
"""
查询单个学生信息
:return:
"""
name = input("请输入要查询的学生的姓名n")
# 查询是否有学生 [{}{}]
if len(stu_list):
# 遍历学生
for stu in stu_list:
if stu['name'] == name:
print(f"姓名为：{stu['name']}，年龄为：{stu['age']}，成绩为：{stu['gender']}")
else:
print("没有该学生的信息")
else:
print("请添加学生信息")
# 打开文件
def save():
f = open('student.txt', 'w', encoding='utf-8')
# 同样str函数把list，dict，tuple转为为字符串
f.write(str(stu_list))
f.close()
# 读取文件
def load_file():
global stu_list
f = open('student.txt', 'r', encoding='utf-8')
buf = f.read()
# 更改全局变量 将str转化为列表
stu_list = eval(buf)
def menu():
while True:
opt = input("--------请您输入操作--------n")
if opt == "1":
print("1.添加学生")
add_stu()
elif opt == "2":
print('2.删除学生')
delete_stu()
elif opt == "3":
print('3.修改学生信息')
update_stu()
elif opt == "4":
print('4.查询单个学生信息')
select_stu()
elif opt == "5":
print('5.查询所有学生')
load_file()
select_all_stu()
elif opt == '6':
print('欢迎您下次登录')
break
elif opt == "7":
print('查看菜单')
print_menu()
else:
print("输入错误请重新输入.....")
continue
save()
menu()
def a():
print_menu()
menu()
a()
成品（类）
import student
class StudentManagerSystem(object):
# 学生列表
# 学生字典{学号: 一个学生信息}
def __init__(self):
self.stu_dicts = {}
@staticmethod
def print_menu():
print('-' * 30)
print('1.添加学生')
print('2.删除学生')
print('3.修改学生信息')
print('4.查询单个学生信息')
print('5.查询所有学生')
print('6.退出系统')
print('7.查看菜单')
def __select_all_stu(self):
for stu in self.stu_dicts.values():
print(f'学号为{stu.stu_id},姓名为：{stu.name},年龄为：{stu.age},性别为：{stu.gender}')
def __add_stu(self):
"""
添加学生信息
:return:
"""
stu_id = input("学号：")
# 判断学生是否存在，因为是字典所以判断key是否存在
if stu_id in self.stu_dicts:
print("该学生信息已存在，请重新添加")
return
name = int(input("姓名："))
age = int(input("年龄："))
gender = input("性别：")
# 创建学生对象
stu = student.Student(stu_id, name, age, gender)
# 将学生对象，存为字典，学号为key值
self.stu_dicts[stu_id] = stu
print("学生信息已经添加成功")
def __delete_stu(self):
"""
删除学生信息
:return:
"""
stu_id = input("请输入要删除的学生的学号n")
# 查询是否有学生
if stu_id in self.stu_dicts:
print(f"学生{self.stu_dicts[stu_id].name}已删除成功")
del self.stu_dicts[stu_id]
# print(f"学生{self.stu_dicts[1]}已删除成功") 已经删除了所以找不到
else:
print("请添加学生信息")
def __update_stu(self):
"""
根据学生姓名修改学生信息
:return:
"""
stu_id = input("请输入要修改的学生的学号n")
# 查询是否有学生 [{}{}]
if stu_id in self.stu_dicts:
stu = self.stu_dicts[stu_id]
stu.age = input('请输入新的年龄')
print("学生信息修改成功")
else:
print("请添加学生信息")
def __select_stu(self):
"""
查询单个学生信息
:return:
"""
stu_id = input("请输入要查询的学生的学号n")
# 查询是否有学生
if stu_id in self.stu_dicts:
stu = self.stu_dicts[stu_id]
print(f'学号为{stu.stu_id},姓名为：{stu.name},年龄为：{stu.age},性别为：{stu.gender}')
else:
print("没有该学生的信息")
# 存入文件
def __save(self):
f = open('student.txt', 'w', encoding='utf-8')
for stu in self.stu_dicts.values():
# 同样str函数把list，dict，tuple转为为字符串
f.write(str(stu)+'n')
f.close()
# 读取文件
def __load_file(self):
f = open('student.txt', 'r', encoding='utf-8')
buf_list = f.readlines() # 读取全部
for buf in buf_list:
buf = buf.strip() # 去除n
info_list = buf.split(',')
# 创建对象
stu = student.Student(*info_list)
stu_id = info_list[0]
self.stu_dicts[stu_id] = stu
f.close()
def menu(self):
self.__load_file()
while True:
opt = input("--------请您输入操作--------n")
if opt == "1":
print("1.添加学生")
self.__add_stu()
elif opt == "2":
print('2.删除学生')
self.__delete_stu()
elif opt == "3":
print('3.修改学生信息')
self.__update_stu()
elif opt == "4":
print('4.查询单个学生信息')
self.__select_stu()
elif opt == "5":
print('5.查询所有学生')
self.__load_file()
self.__select_all_stu()
elif opt == '6':
print('欢迎您下次登录')
break
elif opt == "7":
print('查看菜单')
self.print_menu()
else:
print("输入错误请重新输入.....")
continue
self.__save()
self.menu()
import StudentManagerSystem as sms
class Student(object):
def __init__(self, stu_id, name, age, gender, ):
self.name = name
self.age = age
self.gender = gender
self.stu_id = stu_id
def __str__(self):
return f"{self.stu_id},{self.name},{self.age},{self.gender}"
if __name__ == '__main__':
stu_sms = sms.StudentManagerSystem()
stu_sms.print_menu()
stu_sms.menu()
包
拆包、组包
交换两个数的值
a, b = b, a 先将(b,a)组包 再将（b，a）拆包为（a，b）
a = 1, 2, 3 # 组包 print(a) # (1, 2, 3) b, c, d = a # 拆包 print(b, c, d) # 1 2 3
my_list=[1,2,3,4,5,6] func(my_list) # ([1,2,3,4,5,6]) 将列表作为一个数据进行传递 func(*my_list) # (1,2,3,4,5,6) 将列表的每一个数据单独进行传递引用
a = [1, 2] b = a print(b) a.append(3) # 添加数据没有改变地址 print(id(a), id(b)) a = 10 b = a print(a, b) a = 20 # 更改内存地址 print(id(a), id(b))类型的可变与不可变
不可变类型有：int float bool str tuple
可变类型有：list dict
内存优化不可变类型的引用地址不变
交互终端中，小整数的概念（-5~~256）在这个范围中使用相同的引用地址，否则开辟新的引用地址 递归
def get_age(num):
"""
递归
"""
if num == 1:
return 18
age = get_age(num - 1) + 2
return age
print(get_age(3))
def func(num):
"""
递归 阶乘
"""
if num == 1:
return 1
num = func(num - 1) * num
return num
print(func(5))
匿名函数
lambda 表达式的语法格式如下：
name = lambda [list] : 表达式
其中，定义 lambda 表达式，必须使用 lambda 关键字；[list] 作为可选参数，等同于定义函数是指定的参数列表；value 为该表达式的名称。
该语法格式转换成普通函数的形式，如下所示：
def name(list): return 表达式 name(list)
显然，使用普通方法定义此函数，需要 3 行代码，而使用 lambda 表达式仅需 1 行。
举个例子，如果设计一个求 2 个数之和的函数，使用普通函数的方式，定义如下：
def add(x, y):
return x+ y
print(add(3,4))
程序执行结果为：7
由于上面程序中，add() 函数内部仅有 1 行表达式，因此该函数可以直接用 lambda 表达式表示：
# 有参数 x，y 没有返回值 add = lambda x,y:print(x+y) # 有参数 x，y 有返回值 add = lambda x,y:x+y print(add(3,4))
eval程序输出结果为：7
eval函数就是实现list、dict、tuple与str之间的转化，同样str函数把list，dict，tuple转为为字符串
集合# my_set: set
# 数据类型为不可变类型
# 集合本身为可变类型 集合无序的 没有重复 可以去重
my_set = {1, 3.14, True, 'hello', (1, 2)}
print(my_set)
# 修改
my_set.remove(1)
print(my_set)
my_set.add(2)
print(my_set)
文件操作
r（只读）
# 1.打开文件，是文件从硬盘中存到内存中
# open(file,mode='r', encoding)
# file要操作的文件名字，类型是str
# mode，文件打开的方式，r(read)只读打开，w(write)只写打开 a(append)追加打开
# encoding 文件的编码格式，常见的编码格式有两种，一种是gbk ，一种是utf-8
# 返回值，文件对象，后续所有的文件操作，都需要通过这个文件对象进行
f = open("1.txt", 'r', encoding='utf-8')
print(f.read())
f.close()
w（只写，会覆盖，会新建）
# 1.打开文件w方式打开文件，文件不存在，会创建文件，文件存在，会覆盖清空源文件
f = open("1.txt", 'w', encoding='utf-8')
f.write(' hello word!n')
f.write(' hello python!n')
f.close()
a（追加，不覆盖，会新建）
# a方式打开文件，追加内容，在文件的末尾写入内容
# 文件不存在，会创建文件
# 注意点:不管是a 方式打开文件，还是w方式打开文件，写入内容，都是使用write()函数
f = open("1.txt", 'a', encoding='utf-8')
f.write(' hello word!n')
f.close()
文件读的操作
f = open("1.txt", 'r', encoding='utf-8')
# 读写文件 文件对象.read(n) n 一次读取多少字节的内容，默认不写，读取全部内容
buf = f.read(3)
print(buf)
print('*' * 20)
# 接着上次读取的位置继续读取
buf = f.read(3)
print(buf)
f.close()
第一次是123
第二次读取的4n5
readline（）
# hello word!
# hello python!
# hello word!
f = open('1.txt', 'r', encoding='utf-8')
# buf = f.readline() # 一次读取一行的内容，返回值是读取到的内容(str)
# print(buf)
buf = f.readlines() # 按行读取，一次读取所有行，返回值是列表，列表中的每一项是一个字符串，即一行的内容
print(buf) # ['hello word!n', 'hello python!n', 'hello word!n']
f.close()
优化
f = open('1.txt', 'r', encoding='utf-8')
# buf = f.readline() # 一次读取一行的内容，返回值是读取到的内容(str)
# print(buf)
buf = f.readlines() # 按行读取，一次读取所有行，返回值是列表，列表中的每一项是一个字符串，即一行的内容
print(buf) # ['hello word!n', 'hello python!n', 'hello word!n']
# strip()去除空格和换行
buf = [i.strip() for i in buf] # ['hello word!', 'hello python!', 'hello word!']
print(buf)
f.close()
读取大文件
一行
f = open('1.txt', 'r', encoding='utf-8')
while True:
buf = f.read(5) # 5个字符读取一次
if buf:
print(buf, end='')
else:
break
f.close()
多行
f = open('1.txt', 'r', encoding='utf-8')
while True:
buf = f.readline() # 5个字符读取一次
if buf:
print(buf, end='')
else:
break
f.close()
f = open('1.txt', 'wb')
f.write('你好'.encode()) # 将str转换为二进制
f.close()
f1 = open('1.txt', 'rb')
buf = f1.read()
print(buf) # b'xe4xbdxa0xe5xa5xbd'
print(buf.decode()) # 将二进制转换为str 你好
f1.close()
文件备份
file_name = input('请输入要备份的文件名')
f = open(file_name, 'rb')
buf = f.read()
f.close()
# 根据源文件名找到文件后缀和文件名 右边第一个点 防止出现文件名为a.c.txt
index = file_name.rfind('.')
# 后缀 file_name[index:]
# 新文件名 file_name[:index]切片 文件名 file_name[index:] 文件“.加类型”
new_file_name = file_name[:index] + '[备份]' + file_name[index:]
print(new_file_name)
f_w = open(new_file_name, 'wb')
f_w.write(buf)
f_w.close()
文件操作
案例-烤地瓜# 有自己的状态，默认是生的 可以进行烧烤
# 地瓜有烧烤的总时间，由每次烧烤的时间累加得出
# 地瓜烧烤时， 需要提供本次烧烤的时间
# 烧烤时，地瓜状态随着烧烤总时间的变化而变化：[0,3)生的 [3,6)半生不熟的 [6,8)熟的 >=8烤熟了
# 输出状态和总时间
class Potato(object):
def __init__(self):
self.total_time = 0
self.status = '生的'
def cook(self, time):
self.total_time += time
if self.total_time < 3:
self.status = '生的'
elif self.total_time < 6:
self.status = '半生不熟的'
elif self.total_time < 8:
self.status = '熟的'
else:
self.status = '焦的'
def __str__(self):
return f'状态:{self.status},总时间:{self.total_time}'
potato = Potato()
potato.cook(6)
print(potato)
# 有自己的状态，默认是生的 可以进行烧烤
# 地瓜有烧烤的总时间，由每次烧烤的时间累加得出
# 地瓜烧烤时， 需要提供本次烧烤的时间
# 烧烤时，地瓜状态随着烧烤总时间的变化而变化：[0,3)生的 [3,6)半生不熟的 [6,8)熟的 >=8烤熟了
# 输出状态和总时间
class Potato(object):
def __init__(self):
self.total_time = 0
self.status = '生的'
# 保存调料的
self.name_list = []
def cook(self, time):
self.total_time += time
if self.total_time < 3:
self.status = '生的'
elif self.total_time < 6:
self.status = '半生不熟的'
elif self.total_time < 8:
self.status = '熟的'
else:
self.status = '焦的'
def __str__(self):
# 拼接字符
buf = ','.join(self.name_list)
if self.name_list:
return f'状态:{self.status},总时间:{self.total_time},调料有{buf}'
else:
return f'状态:{self.status},总时间:{self.total_time},还没有添加调料'
def add(self, name):
self.name_list.append(name)
potato = Potato()
potato.cook(6)
potato.add('油')
print(potato)
# 家具类
class Furniture(object):
def __init__(self, name, area):
self.name = name
self.area = area
def __str__(self):
return f'家具的类型为{self.name},家具的面积为：{self.area}'
# 房子类
class House(object):
def __init__(self, address, area):
self.address = address # 地址
self.h_area = area # 房子面积
self.furniture_list = [] # 家具
self.free_area = area # 房子剩余面积
def add_furniture(self, obj_furniture):
if self.free_area >= obj_furniture.area:
# 家具添加
self.furniture_list.append(obj_furniture)
# 面积修改
self.free_area -= obj_furniture.area
print(f'家具{obj_furniture.name} 添加成功')
else:
print('添加失败，换一个大房子')
def __str__(self):
return f'房子的地址为{self.address},占地面积为：{self.h_area},剩余面积为：{self.free_area}'
bed = Furniture('单人床', 300)
print(bed)
house = House('故宫', 400)
print(house)
house.add_furniture(bed)
print(house)
# 定义Dog类，定义bark方法和eat方法
class Dod(object):
def bark(self):
print('汪汪汪叫。。。')
def eat(self):
print('啃骨头。。。')
class God(object):
def play(self):
print('在云中飘会。。。')
def eat(self):
print('吃蟠桃仙丹。。。')
class XTQ(God, Dod):
pass
xtq = XTQ()
xtq.bark()
xtq.play()
xtq.eat()
静态方法
ime += time
if self.total_time < 3:
self.status = ‘生的’
elif self.total_time < 6:
self.status = ‘半生不熟的’
elif self.total_time < 8:
self.status = ‘熟的’
else:
self.status = ‘焦的’
def __str__(self):
# 拼接字符
buf = ','.join(self.name_list)
if self.name_list:
return f'状态:{self.status},总时间:{self.total_time},调料有{buf}'
else:
return f'状态:{self.status},总时间:{self.total_time},还没有添加调料'
def add(self, name):
self.name_list.append(name)
potato = Potato()
potato.cook(6)
potato.add(‘油’)
print(potato)
```python
# 家具类
class Furniture(object):
def __init__(self, name, area):
self.name = name
self.area = area
def __str__(self):
return f'家具的类型为{self.name},家具的面积为：{self.area}'
# 房子类
class House(object):
def __init__(self, address, area):
self.address = address # 地址
self.h_area = area # 房子面积
self.furniture_list = [] # 家具
self.free_area = area # 房子剩余面积
def add_furniture(self, obj_furniture):
if self.free_area >= obj_furniture.area:
# 家具添加
self.furniture_list.append(obj_furniture)
# 面积修改
self.free_area -= obj_furniture.area
print(f'家具{obj_furniture.name} 添加成功')
else:
print('添加失败，换一个大房子')
def __str__(self):
return f'房子的地址为{self.address},占地面积为：{self.h_area},剩余面积为：{self.free_area}'
bed = Furniture('单人床', 300)
print(bed)
house = House('故宫', 400)
print(house)
house.add_furniture(bed)
print(house)
# 定义Dog类，定义bark方法和eat方法
class Dod(object):
def bark(self):
print('汪汪汪叫。。。')
def eat(self):
print('啃骨头。。。')
class God(object):
def play(self):
print('在云中飘会。。。')
def eat(self):
print('吃蟠桃仙丹。。。')
class XTQ(God, Dod):
pass
xtq = XTQ()
xtq.bark()
xtq.play()
xtq.eat()
静态方法
