Python学习笔记-优快云博客

一、名词解释

二、数据类型（变量名无类型，变量值有类型）

一、名词解释

1、字面量

被写在代码中的固定的值称为字面量，示例如下：

100  
100.01  
"hello world"  
  
print(100)  
print(100.01)  
print("hello world")

2、注释

对代码进行解释说明的文字
注释不是代码，不会被程序执行

# 单行注释，#号开头

"""
多行注释，首尾三个引号，一般写在文件开头
"""

3、变量

变量就是在程序运行时，记录数据用的
变量名 = 变量值
局部变量：定义在函数体内部的变量，只在函数体内部生效
全局变量：定义在函数体外部的变量，函数体内外都生效

# 定义变量money,值为50，并打印出来
money = 50
print("钱包还有：",money)

# 买了一个冰淇淋花费10元
money = money - 10
print("买了一个冰淇淋花费10元,还剩余：",money,"元")

二、数据类型（变量名无类型，变量值有类型）

数字类型（Number）
int: 整数(有符号)，存放整数 如-1,10,0等
float: 浮点数(有符号)，存放小数，如-3.13,6.66
complex: 复数，如：4+3j，以j结尾表示复数
bool: 布尔，True是真，False是假，本质上是一个数字记作1，False记作0

字符串(String): 用引号引起来的数据都是字符串
列表(List): 有序的可变序列，Python中使用最频繁的数据类型，可有序记录一堆数据
元组(Tuple): 有序的不可变序列，可有序记录一堆不可变的Python数据集合
集合(Set): 无序不重复集合，可无序记录一堆不重复的Python数据集合
字典(Dictionary): 无序Key-Value集合，可无序记录一堆Key-Value型的Python数据集合

查看类型：type(被查看类型的数据)

示例

# 定义一个变量name，值为张三
name = "张三"

# 得到变量name的值的类型
name_type = type(name);

print("变量值：",name,"，类型：",name_type)
print("字面量：",111,"，类型：",type(111))

# 定义一个int类型变量值
num = int(111)
print("num：",num,"，类型：",type(num))

三、数据类型转换(万物皆可转字符串)

数据类型之间，在特定的场景下，是可以相互转换的，如字符串转数字、数字转字符串等。

如：
从文件中读取的数字，默认是字符串，我们需要转换成数字类型
后续学习的input()语句，默认结果是字符串，若需要数字也需要转换
将数字转换成字符串用以写出到外部系统

int(x): 将x转换为一个整数
float(x): 将x转换为一个浮点数
str(x): 将对象x转换为字符串

示例

# 将数字类型转换成字符串
num1 = str(11.1)
num2 = int(10)
num3 = str(num2)

print("num1：",type(num1),",num2:",type(num2),"num3:",type(num3))

# 将字符串转换成数字
num4 = float("1.345")
num5 = int("100")
print(type(num4),num4,type(num5),num5)

四、标识符

标识符包括变量的名字、方法的名字、类的名字等等，用来做内容的标识。

1、规则

标识符命名中只允许出现英文、中文、数字、下划线这四类元素，其余内容都不被允许。
不推荐使用中文。
数字不可以开头。
大小写敏感，admin和Admin能够区分。
不可使用关键字。

2、变量的命名规范：见名知意，下划线命名法，英文字母全小写。


name = "张三"
user_name = "李四"

3、关键字

False    True    None  and    as     assert   break   class 
continue def     del   elif   else   except   finally for
from     global  if    import in     is       lambda  nonlocal
not      yield   pass  raise  return try      while   with     or

4、示例

# 错误示例 数字不可以开头,运行报错
1_num = 10

# 错误示例 使用四类之外元素,运行报错
$_num =10

# 错误示例 大小写敏感,运行报错
admin = "张三"
print(Admin)

# 错误示例 不可使用关键字,运行报错
False = 100

五、运算符

1、算术（数学）运算符示例

a = 10
b = 3

print("a+b = ", a + b)  # 加，两个对象相加a+b输出结果13  
print("a-b = ", a - b)  # 减，得到负数或是一个数减去另一个数a-b输出结果7  
print("a*b = ", a * b)  # 乘，或是返回一个被重复若干次的字符串，输出结果30  
print("a/b = ", a / b)  # 除，b/a输出结果3.3333333333333335  
print("a//b = ", a // b)  # 取整除，保留整数，舍去小数，输出结果3  
print("a%b = ", a % b)  # 取余，返回除法的余数b%a输出结果1  
print("a**b = ", a ** b)  # 指数，a**b为10的3次方，输出结果1000

2、赋值运算符示例

# 把 = 号右边的结果赋给左边的变量，如num=1+2*3，结果num的值为7
num = 1+2*3
print("num: ",num)

3、复合赋值运算符

a += b  # 加法赋值运算符,等效于a = a+b  
print("a = ", a)  # 输出结果13  
  
a -= b  # 减法赋值运算符,等效于a = a-b  
print("a = ", a)  # 输出结果10  
  
a *= b  # 乘法赋值运算符,等效于a = a*b  
print("a = ", a)  # 输出结果30  
  
a /= b  # 除法赋值运算符,等效于a = a/b  
print("a = ", a)  # 输出结果10.0  
  
a %= b  # 取模赋值运算符,等效于a = a%b  
print("a = ", a)  # 输出结果1.0  
  
a **= b  # 幂赋值运算符,等效于a = a**b  
print("a = ", a)  # 输出结果1.0  
  
a //= b  # 取整赋值运算符,等效于a = a//b  
print("a = ", a)  # 输出结果0.0

4、比较运算符

a = 3  
b = 4  
print("a==b：", (a == b))  # 判断a是否等于b，是为True，否为False，结果：False  
print("a!=b：", (a != b))  # 判断a是否不等于b，是为True，否为False，结果：True  
print("a>b：", (a > b))  # 判断a是否大于b，是为True，否为False，结果：False  
print("a<b：", (a < b))  # 判断a是否小于b，是为True，否为False，结果：True  
print("a>=b：", (a >= b))  # 判断a是否大于等于b，是为True，否为False，结果：False 
print("a<=b：", (a <= b))  # 判断a是否小于等于b，是为True，否为False，结果：True

六、字符串扩展

1、字符串在Python中有很多种

# 单引号定义法  
name = '张三'  
print(type(name))  
  
# 双引号定义法  
name = "张三"  
print(type(name))  
  
# 三引号定义法，支持换行操作，使用变量接收为字符串，否则为多行注释  
name = """张三\n张三"""  
print(type(name))

2、字符串本身包含单引号、双引号自身

# 单引号定义法，可以内含双引号  
name = '"张三"'  
print(name)  
  
# 双引号定义法，可以内含单引号  
name = "'张三'"  
print(name)  
  
# 可以使用转义字符\来将引号解除效用，变成普通字符串  
name = "\"张三\""  
print(name)  
name = '\'张三\''  
print(name)

3、字符串拼接

# 通过+号完成，字面量拼接
print("你好" + "张三")  
  
# 字面量和变量拼接  
name = "张三"  
print("你好" + name)

# 错误示例，和数字拼接，执行报错，无法和非字符串拼接
num = 100  
print("你好张三" + num)
print("你好张三" + 100)

4、字符串格式化

# %s 字符串占位符 %d 整数占位符 %f 浮点数占位符  
name = "张三"  
num = 100  
fraction = 99.8  
print("你好%s%d，成绩：%f" % (name, num, fraction))  # 输出结果：你好张三100，成绩：99.800000

# f"{变量}" # 输出结果：你好张三，成绩：99.8  
print(f"你好{name}，成绩：{fraction}")

5、格式化的精度控制（m.n）

# m，控制宽度，要求是数字（很少使用），设置的宽度小于数字自身，不生效,空格占位
num = 3  
num1 = 11.2345  
print("%5d" % num)  # 输出结果：    3
print("%5d" % num1) # 输出结果：   11
print("%d" % num)   # 输出结果：3

# .n，控制小数点精度，要求是数字，会进行小数的四舍五入
num = 1.235  
print("%5.2f" % num)  # 输出结果： 1.24
print("%.2f" % num)   # 输出结果：1.24

6、对表达式进行格式化

print("1+1=%d" % (1 + 1))  
print(f"1+1={1 + 1}")  
print("类型为：%s" % type('字符串'))

七、数据输入

name = input("请输入姓名：")  
age = int(input("请输入年龄："))  

# if语句，内容四个空格缩进
if age < 18:  
    print("年龄小于18岁")  
  
print("输出的姓名为：%s" % name)  
print("输出的年龄为：%d" % age)

八、if语句

name = input("请输入姓名：")  
age = int(input("请输入年龄："))  
  
# 随机数  
import random  
num = random.randint(1, 10)  
  
if age < 18:  
    print("年龄小于18岁，随机数为：",num)  
elif age == 18:  
    print("年龄等于18岁")  
elif int(input("年龄输入错误，请重新输入：")) > 18:  
    print("年龄输入错误，结束！")  
else:  
    if age < 18:  
        print("年龄小于18岁，结束！")  
    else:  
        print("年龄等于18岁，结束！")  
  
print("输出的姓名为：%s" % name)  
print("输出的年龄为：%d" % age)

九、while语句

count = int(input("请输入随机次数："))  
  
if count > 1:  
    print("开始随机，随机次数：", count)  
elif (count := int(input("随机次数不符合规则，请重新输入："))) < 1:  
    print("随机数不符合规则，结束！")  
else:  
    print("开始随机，随机次数：", count)  
  
# 随机数  
import random  
  
# 循环随机  
i = 0  
while i < count:  
    if i > 15:  
        break  
    elif i > 11:  
        continue  
  
    # 循环1-10之间的数字  
    num = random.randint(1, 10)  
    print("i=", i, ",num=", num)  
    i += 1

十、for循环语句

1、循环处理字符串

name = input("请输入名称：")  
  
print("打印name：")  # 结果：每个字符换行打印  
for s in name:  
    if s == 'a':  
        print("打印：", s)  
        continue  
    if s == 'n':  
        print("打印：", s)  
        break  
    print(s)  
  
# 规范上不允许，实际能打印s  
print(s)

2、range语句

# range(5)获取一个0-4的数字序列，结果:换行打印0 1 2 3 4 
print("range(5):")  
for i in range(5):   

    print(i)  

# range(5, 8)获取一个5-7的数字序列，结果：换行打印5 6 7  
print("range(5,8)")  
for i in range(5, 8):  
    print(i)  

 #  range(5, 11, 2)获取一个5-10的数字序列，数字之间步长为2，结果：换行打印5 7 9  
print("range(5,11,2)")  
for i in range(5, 11, 2): 
    print(i)

十一、函数

def关键字，可以定义带有名称的函数，可以基于名称重复使用
lambda关键字，可以定义匿名函数(无名称)，只可以临时使用一次

1、定义函数my_len

def my_len(data):  
    """  
    统计字符串长度  
    :param data: 参数data  
    :return: 返回值  
    """   
    count = 0  
    for i in data:  
        count += 1  
    print("字符串：", data, "，长度：", count)  
    return count
  
  
# 调用my_len函数计算打印字符串长度  
count = my_len("admin")  
print("得到长度：", count)

2、返回None

def check(data):  
    """  
    检查函数  
    :param data: 参数data  
    :return: 返回值  
    """    
    if data == "":  
        return None  
    else:  
        return "Success"  
  
result = check("")  
if not result:  
    print("参数为空")

3、函数的多返回值

# 该种方式只能返回第一个值  
def return_num():  
    return 1  
    return 2  
print("函数的多返回值：",return_num()) # 结果：1  
  
# 多个返回值  
def test_return():  
    return 1,'a',True  
x,y,z=test_return()  
print("返回值x=",x,",类型：",type(x)) # 返回值x= 1 ,类型： <class 'int'>
print("返回值y=",y,",类型：",type(y)) # 返回值y= a ,类型： <class 'str'>
print("返回值z=",z,",类型：",type(z)) # 返回值z= True ,类型： <class 'bool'>

4、函数的多种参数使用形式

# 位置参数：调用时根据函数定义的参数位置来传递参数，传递时顺序和个数必须一致  
def add_user(txt, name, age):  
    print(txt, "：", name, ",", age)  
add_user('位置参数', '张三', 18)  
  
# 关键字参数：函数调用时通过“键=值”形式传递参数，位置参数必须在关键字参数之前  
add_user('关键字参数', age=19, name='李四')  # 关键字参数 ： 李四 , 19  
# 缺省参数：缺省参数也叫默认参数，用于定义函数时为参数提供默认值，调用函数时可不传该默认参数的值，  
# 所有位置参数必须出现在默认参数前，包括函数定义和调用  
def update_user(name, age, gender='男'):  
    print("缺省参数：", name, ",", age, ",", gender)  
update_user("张三", 18)  # 缺省参数： 张三 , 18 , 男  
update_user("李四", 28, '女')  # 缺省参数： 李四 , 28 , 女  
  
# 位置不定长(*args)：传递以*号标记一个形式参数，以元组形式接收参数，形式参数一般命名为args  
def add_user(*args):  
    print("位置不定长: ", args, ",类型：", type(args))  
add_user("张三", 18)  # 位置不定长:  ('张三', 18) ,类型： <class 'tuple'>  
# 关键字不定长(**kwargs):以**号标记一个形式参数，以字典的形式接收参数，形式参数一般命名为kwargs，参数为key=value形式  
def add_user(**kwargs):  
    print("关键字不定长: ", kwargs, ",类型：", type(kwargs))  
add_user(name="张三", age=18) # 关键字不定长:  {'name': '张三', 'age': 18} ,类型： <class 'dict'>

5、函数作为参数传递

def test_func(compute):  
    print(compute(1, 2))  
  
def compute(x, y):  
    return x + y  
  
test_func(compute)  # 结果：3

6、lambda匿名函数：lambda 传入参数:函数体(一行代码)

def test_func(compute):  
    print(compute(1, 2))  
    
test_func(lambda a, b: a + b)

十二、数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素，
每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

数据容器根据特点的不同，如：是否支持重复元素，是否可以修改，是否有序等分为5类：
列表（list），元组（tuple），字符串（str），集合（set），字典（dict）

列表、元组、字符串：支持下标索引，支持重复元素 -序列类型
列表、集合、字典：支持修改

通用操作：len(容器)、max(容器)、min(容器)
通用排序功能: sorted(容器,reverse=True)

1、List列表

"""  
List操作  
append，extend，insert，del，pop，remove，clear，count，index，len  
特点  
可容纳多个元素，上限为2**63-1,9223372036854775807个  
可以容纳不同类型的元素（混装）  
数据是有序存储的（有下标序号）  
允许重复数据存在  
可以修改（增加或删除元素）  
"""  
# 字面量  
[1, 'a', True]  
  
# 定义空列表  
user_list = []  
user_list = list()  
# 追加元素  
user_list.append('a')  
user_list.append('b')  
# 在指定下标添加元素 -1 会添加到倒数第二的位置 -0无效  
user_list.insert(2, 'c')  
  
# 将其他列表数据追加到列表尾部  
user_list.extend([1, 2, 3])  
  
# 删除指定下标元素  
del user_list[0]  
# 得到指定下标元素并从列表移除元素,不给下标默认删除末尾元素  
user_list.pop(0)  
# 删除某元素在列表中的第一个匹配项  
user_list.remove('c')  
# 清空列表  
user_list.clear()  
  
print(user_list)  
  
# 定义变量  
user_list = ['张三', 666, True]  
print(user_list)  
print(type(user_list))  
# 得到指定元素下标,列表中的第一个匹配项，不存在报错  
print("下标: ", user_list.index(666))  
# 统计列表内某元素的数量  
print("个数: ", user_list.count(666))  
# 统计列表中全部元素数量  
print("总数: ", len(user_list))  
  
# 顺序下标取值，0为开始索引  
print(user_list[0])  
  
# 反向下标取值(倒序取值)，从最后一个元素开始，-1，-2，-3  
print(user_list[-1])  
  
# while遍历  
i = 0  
while i < len(user_list):  
    print("while遍历元素: ", user_list[i])  
    i += 1  
  
# for遍历  
for i in user_list:  
    print("for遍历元素: ", i)  
  
# 嵌套列表  
user_list = [[1, 2, 3], [4, 5, 6]]  
print(user_list)  
print(user_list[0][2])  # 结果：3  
print(user_list[-1][-1])  # 结果：6

2、tuple元组

"""  
定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型  
特点：  
可以容纳多个数据  
可以容纳不同类型的数据（混装）  
数据是有序存储的（下标索引）  
允许重复数据存在  
不可以修改（增加或删除元素等）  
支持for循环  
多数特性和list一致，不同点在于不可修改的特性。  
"""  
# 元组字面量  
(1, 'a', True)  
  
# 空元组  
tuple_data = ()  
tuple_data = tuple()  
  
# 元组变量  
tuple_data = (1, 2, 3, 3)  
print("下标: ", tuple_data.index(3))  
print("个数: ", tuple_data.count(3))  
print("总数: ", len(tuple_data))  
  
# while遍历  
i = 0  
while i < len(tuple_data):  
    print("while遍历元素: ", tuple_data[i])  
    i += 1  
  
# for遍历  
for i in tuple_data:  
    print("for遍历元素: ", i)  
  
# 嵌套元组  
tuple_data = ((1, 2, 3), ('a', 'b', 'c'))  
print(tuple_data)  
print(tuple_data[1][1])  # 结果：b  
print(tuple_data[-1][1])  # 结果：b

3、字符串

"""  
字符串是字符的容器，一个字符串可以存放任意数量的字符。  
在程序中，字符串所用的所有字符如：大小写英文单词、数字、特殊符号都有其对应的ASCII码表值  
每一个字符都能对应上一个：数字的码值  
字符串进行比较就是基于数字的码值大小进行比较的  
字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大，那么后面就无需比较  
"""  
# 字符串比较，结果：ab>a =  True  
print("ab>a = ",'ab'>'a')  
  
# 通过下标获取特定位置的字符  
name = "admin"  
# 获取指定下标元素  
print(name[0])  
# 倒序获取指定下标元素 结果：n  
print(name[-1])  
# 替换元素 结果：bdmin  
print(name.replace("a", "b"))  
# 查找特定字符串的下标索引 结果：3  
print(name.index("in"))  
  
# 字符串分隔，得到一个新的List列表  
name = " abc def d "  
strList = name.split(" ")  
print(strList)  # 结果：['', 'abc', 'def', 'd', '']  
print(type(strList))  
  
# strip无参 去掉首尾空格 结果：abc def d  
print(name.strip())  
  
# strip带参,去除首尾包含的这个元素及空格，先去元素再去空格  
print(name.strip(" abc"))  # def d  
print(name.strip(" abc").split(" "))  # ['def', 'd']  
  
# 统计特定字符的出现次数  
print("个数: ", name.count("d"))  
  
# 统计字符串的长度  
print("个数: ", len(name))

4、序列的常用操作-切片

"""  
序列支持切片，即：列表、元组、字符串，均支持进行切片操作  
切片：从一个序列中，取出一个子序列  
语法：序列[起始下标:结束下标:步长]  
起始下标表示从何处开始，可以留空，留空视作从头开始  
结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾  
步长表示，依次取元素的间隔  
步长1表示，一个个取元素  
步长2表示，每次跳过1个元素取  
步长N表示，每次跳过N-1个元素取  
步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）  
"""  
  
# 对list列表进行切片  
user_list = [1, 2, 3, 4, 5, 6]  
sub_list = user_list[1:4]  # 切下标1到4，步长1，结果：[2, 3, 4]  
print("user_list: ", user_list, ",sub_list: ", sub_list)  
  
sub_list = user_list[1:6:2]  # 切下标1到6，步长2，结果：[2, 4, 6]  
print("user_list: ", user_list, ",sub_list: ", sub_list)  
  
sub_list = user_list[-1:-6:-2]  # 切下标-1到-6，步长-2，结果：[6, 4, 2]  
print("user_list: ", user_list, ",sub_list: ", sub_list)  
  
# 对tuple元组进行切片  
tuple_data = (1, 2, 3, 4, 5, 6)  
sub_tuple = tuple_data[1:4]  # 切下标1到4，步长1，结果：(2, 3, 4)  
print("tuple_data: ", tuple_data, ",sub_tuple: ", sub_tuple)  
  
sub_tuple = tuple_data[1:6:2]  # 切下标1到6，步长2，结果：(2, 4, 6)  
print("tuple_data: ", tuple_data, ",sub_tuple: ", sub_tuple)  
  
sub_tuple = tuple_data[-1:-6:-2]  # 切下标-1到-6，步长-2，结果：(6, 4, 2)  
print("tuple_data: ", tuple_data, ",sub_tuple: ", sub_tuple)  
  
# 对str字符串进行切片  
num_str = "123456"  
sub_num = num_str[1:4]  # 切下标1到4，步长1，结果：234  
print("num_str: ", num_str, ",sub_num: ", sub_num)  
  
sub_num = num_str[1:6:2]  # 切下标1到6，步长2，结果：246  
print("num_str: ", num_str, ",sub_num: ", sub_num)  
  
sub_num = num_str[-1:-6:-2]  # 切下标-1到-6，步长-2，结果：642  
print("num_str: ", num_str, ",sub_num: ", sub_num)

5、set集合

"""  
特点:  
可以容纳多个数据  
可以容纳不同类型的数据(混装)  
数据是无序存储的(不支持下标索引)  
不允许重复数据存在  
可以修改(增加或删除元素等)  
支持for循环  
"""  
# 字面量  
{1, 'a', True}  
  
# 空集合  
set_data = set()  
  
# 定义集合变量  
set_data = {1, 2, 3}  
print(set_data)  
print(type(set_data))  
  
# 添加新元素,重复元素不能添加  
set_data.add(3)  
set_data.add(4)  # 结果：{1, 2, 3, 4}  
  
# 移除元素  
set_data.remove(4)  # 结果：{1, 2, 3}  
  
# 统计集合元素数量  
print("总数: ", len(set_data))  
  
# 取出集合第一个元素并从集合中移除  
print(set_data.pop())  
print(set_data)  
  
# 清空集合  
set_data.clear()  
print(set_data)  
  
# 两个集合的差集/并集  
set1 = {1, 2, 3}  
set2 = {3, 4, 5}  
  
# 差集，取出集合1有而集合2没有的集合数据 结果：{1, 2}  
print("差集: ", set1.difference(set2))  
  
# 差集，取出集合2有而集合1没有的集合数据 结果：{4, 5}  
print("差集: ", set2.difference(set1))  
  
# 在集合中，删除集合2中存在的元素，集合1被修改，集合2不变  
print("差集: ", set1.difference_update(set2))  # 结果：None  
print(set1)  # 结果: {1, 2}  
print(set2)  # 结果: {3, 4, 5}  
  
# 并集,将集合1和集合2组成新集合 结果：{1, 2, 3, 4, 5}  
print("并集: ", set1.union(set2))  
  
# 遍历  
for s in set2:  
    print("for遍历：", s)

6、dict字典

"""  
特点：  
可以容纳多个数据  
可以容纳不同类型的数据  
每一份数据是key:value键值对  
可以通过key获取到value,key不可重复(重复会覆盖)  
不支持下标索引  
可以修改(增加或删除更新元素等)  
支持for循环，不支持while循环  
"""  
# 字面量  
{"name": "张三", "age": 18}  
  
# 空字典  
dict_data = {}  
dict_data = dict()  
  
# 定义字典变量  
dict_data = {"name": "张三", "age": 18}  
print(dict_data)  
print(type(dict_data))  
  
# 根据Key取Value值 结果：张三  
print(dict_data["name"])  
  
# 添加元素 结果: {'name': '张三', 'age': 18, 'status': False}  
dict_data["status"] = False  
print(dict_data)  
  
# 修改元素  
dict_data["name"] = "张三1"  
  
# 从字典中根据Key获取元素值并从字典中移除对应key:value  
print(dict_data.pop("name"))  
  
# 字典中的元素数量  
print("总数：", len(dict_data))  
  
# 获取全部key  
keys = dict_data.keys()  
  
# 遍历  
for s in keys:  
    print("for遍历: ", s, "，值: ", dict_data[s])  
  
for key in dict_data:  
    print("for遍历2: ", key, "，值: ", dict_data[key])  
  
# 清空元素  
dict_data.clear()  
  
print(dict_data)

7、数据容器相互转换

"""  
五大数据容器：list,tuple,str,set,dict  
list,tuple,str,set之间可以互转，但不可以转为dict  
dict可以转为其他四种类型，str类型key:value全转，其他类型只转keys  
"""  
  
# list转其他数据容器,不能转dict  
user_list = [1, 2, 3]  
print(f"list转tuple: {tuple(user_list)}")  # (1, 2, 3)  
print(f"list转str: {str(user_list)}")  # [1, 2, 3]  
print(f"list转set: {set(user_list)}")  # {1, 2, 3}  
# print(f"list转dict: {dict(user_list)}")  
  
# tuple转其他数据容器,不能转dict  
tuple_data = (1, 2, 3)  
print(f"tuple转list: {list(tuple_data)}")  # [1, 2, 3]  
print(f"tuple转str: {str(tuple_data)}")  # (1, 2, 3)  
print(f"tuple转set: {set(tuple_data)}")  # {1, 2, 3}  
# print(f"tuple转dict: {dict(tuple_data)}")  
  
# str转其他数据容器,不能转dict  
str_data = (1, 2, 3)  
print(f"str转list: {list(str_data)}")  # [1, 2, 3]  
print(f"str转tuple: {tuple(str_data)}")  # (1, 2, 3)  
print(f"str转set: {set(str_data)}")  # {1, 2, 3}  
# print(f"str转dict: {dict(str_data)}")  
  
# set转其他数据容器,不能转dict  
set_data = {1, 2, 3}  
print(f"set转list: {list(set_data)}")  # [1, 2, 3]  
print(f"set转tuple: {tuple(set_data)}")  # (1, 2, 3)  
print(f"set转str: {str(set_data)}")  # {1, 2, 3}  
# print(f"set转dict: {dict(set_data)}")  
  
# dict转其他数据容器,不能转dict  
dict_data = {1: 'a', 2: 'b', 3: 'c'}  
print(f"dict转list: {list(dict_data)}")  # [1, 2, 3]  
print(f"dict转tuple: {tuple(dict_data)}")  # (1, 2, 3)  
print(f"dict转str: {str(dict_data)}")  # {1: 'a', 2: 'b', 3: 'c'}  
print(f"dict转set: {set(dict_data)}")  # {1, 2, 3}

8、通用操作

"""  
五大数据容器：list,tuple,str,set,dict  
通用操作：len(容器,),min(容器,),max(容器,),  
倒序操作：sorted(容器,reverse=True) 返回值为list，dict只返回key  
"""  
  
# list使用通用操作 结果：长度: 3,最小值: 1,最大值: 3  
# 倒序: [3, 2, 1],原数据:[1, 2, 3],倒序类型: <class 'list'>  
list_data = [1, 2, 3]  
print(f"list\n长度: {len(list_data)},最小值: {min(list_data)},最大值: {max(list_data)}")  
print(f"倒序: {sorted(list_data, reverse=True)},原数据:{list_data}")  
print(f"倒序类型: {type(sorted(list_data, reverse=True))}\n")  
  
# tuple使用通用操作 结果：长度: 3,最小值: 1,最大值: 3  
# 倒序: [3, 2, 1],原数据:(1, 2, 3),倒序类型: <class 'list'>  
tuple_data = (1, 2, 3)  
print(f"tuple\n长度: {len(tuple_data)},最小值: {min(tuple_data)},最大值: {max(tuple_data)}")  
print(f"倒序: {sorted(tuple_data, reverse=True)},原数据:{tuple_data}")  
print(f"倒序类型: {type(sorted(tuple_data, reverse=True))}\n")  
  
# str使用通用操作 结果：长度: 3,最小值: a,最大值: c  
# 倒序: ['c', 'b', 'a'],原数据:abc,倒序类型: <class 'list'>  
str_data = "abc"  
print(f"str\n长度: {len(str_data)},最小值: {min(str_data)},最大值: {max(str_data)}")  
print(f"倒序: {sorted(str_data, reverse=True)},原数据:{str_data}")  
print(f"倒序类型: {type(sorted(str_data, reverse=True))}\n")  
  
# set使用通用操作 结果：长度: 3,最小值: 1,最大值: 3  
# 倒序: [3, 2, 1],原数据:{1, 2, 3},倒序类型: <class 'list'>  
set_data = {1,2,3}  
print(f"set\n长度: {len(set_data)},最小值: {min(set_data)},最大值: {max(set_data)}")  
print(f"倒序: {sorted(set_data, reverse=True)},原数据:{set_data}")  
print(f"倒序类型: {type(sorted(set_data, reverse=True))}\n")  
  
  
# dict使用通用操作 结果：长度: 3,最小值: 1,最大值: 3  
# 倒序: [3, 2, 1],原数据:{1: 'a', 2: 'b', 3: 'b'},倒序类型: <class 'list'>  
dict_data = {1: 'a', 2: 'b', 3: 'b'}  
print(f"dict\n长度: {len(dict_data)},最小值: {min(dict_data)},最大值: {max(dict_data)}")  
print(f"倒序: {sorted(dict_data, reverse=True)},原数据:{dict_data}")  
print(f"倒序类型: {type(sorted(dict_data, reverse=True))}\n")

十三、文件编码

编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑。  
编码有许多种，最常用的是UTF-8编码  
  
文件可分为文本文件、视频文件、音频文件、图像文件、可执行文件等多种类别

1、读取操作

"""  
open()打开函数  
open(name,mode,encoding)  
name:目标文件名的字符串(可包含文件所在的具体路径)  
mode:设置打开文件的模式（访问模式）  
	只读(r):以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。  
	写入(w):打开一个文件只用于写入。如果该文件已存在则打开文件，并从头开始编辑，原有内容会被删除，如果不存在则创建新文件。  
	追加(a):打开一个文件用于追加。如果该文件已存在，新的内容将会被写入到已有内容之后，如果该文件不存在，创建新文件进行写入。
encoding:编码格式(推荐使用UTF-8),encoding的顺序不是第三位，所以要用关键字参数直接指定。
"""  
import time  
  
# 内容：name = "张三"  
f = open('main.py', 'r', encoding='UTF-8')  
print(type(f))  
  
# read()方法，无参读全部数据，传参读取，参数为字节数，代表读取长度  
print(f.read(3))  # 结果：nam  
print(f.read())  # 结果：e = "张三" age = 18  
  
# 关闭文件对象  
f.close()  
  
# 通过with open语法打开文件，可以自动关闭  
with open('main.py', 'r', encoding='UTF-8') as f:  
    # 读取全部文件  
    list_data = f.readlines()  
    print(list_data)  # 结果：['name = "张三"\n', 'age = 18']  
    # print(f.readline()) # 读取一行  
  
    # for循环文件行，一次循环得到一行数据  
    for l in list_data:  
        print("for遍历：", l)  
  
# 程序睡眠  
time.sleep(500000)

2、写入操作

"""  
直接调用write，内容并未真正写入文件，而是会积攒在程序的内存中，称之为缓冲区  
当调用flush时，内容会真正写入文件  
这样做是避免频繁的操作硬盘，导致效率下降  
w模式，文件不存在，会创建新文件，存在，会清空原有内容  
close()方法，带有flush()方法的功能  
"""  
# 打开文件  
f = open('test.txt', 'w', encoding="UTF-8")  
  
# 写入内容  
f.write('hello world')  
  
# 刷新内容到硬盘中  
f.flush()  
  
# 关闭文件  
f.close()  
  
# 打开一个存在的文件  
f = open('test.txt', 'w', encoding="UTF-8")  
f.write("张三")  
f.close()

3、追加操作

"""  
a模式，文件不存在会创建文件，存在，会在最后追加写入文件  
"""  
# 打开文件  
f = open('test.txt', 'a', encoding="UTF-8")  
  
# 文件写入  
f.write("王五")  
  
# 关闭文件  
f.close()