语法基础和数据类型

import keyword
print(keyword.kwlist)

# 单个变量赋值
x = 10

# 多变量同时赋值
a, b, c = 5, 3.2, "Hello"

# 交换两个变量的值
a, b = b, a

# 错误的命名，因为 if 是一个关键字
if = 10  # 这将引发语法错误

# 正确的命名
if_condition = 10

print(2 + 2)  # 加法
print(50 - 5 * 6)  # 减法
print((50 - 5 * 6) / 4)  # 除法
print(8 / 5)  # 除法总是返回一个浮点数

import math

print("圆周率：", math.pi)
print("自然对数的底数：", math.e)

x = 2.5
y = 3.7

print(x, "的平方根：", math.sqrt(x))
print(y, "的向下取整值：", math.floor(y))

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

# 0 1 2 3 4 5 6 7 8 9
a = 0

# 10.1
# 10.0
# 10.25
a = 10.1

# 使用 complex 函数
c1 = complex(2, 3)  # 创建复数 2 + 3j

# 直接定义
c2 = 2 + 3j  # 同样创建复数 2 + 3j

[1, '武松', 12.3, True]
# 示例：
a = [1, '武松', 12.3, True]

(1, '武松', 12.3, True)
# 示例
a = (1, '武松', 12.3, True)

L = ('spam', 'Spam', 'SPAM!')

作用：
		取序列类型的一个元素
	从左往右取值 从0开始：

# 以变量a为例子
a = '我真的很帅'

a[0] # 我
a[1] # 真
a[2] # 的
a[3] # 很
a[4] # 帅

# 以变量a为例子
a = '我真的很帅'

作用：
		取序列类型的多个元素
	如何使用？

[形参1:形参2:形参3]
# 形参1 是从索引几开始
# 形参2 是到索引几结束 但是不包含当前索引
# 形参3 是步长 根据索引每次走几步
a = '我真的很帅'
print(a[0:3:1]) # 我真的
print(a[0:3:2])	# 我的

my_list = ['apple', 'banana', 'cherry']
my_string = ', '.join(my_list)
print(my_string)  # 输出: apple, banana, cherry

lst = [1, 2, 3, 4, 5]
result_str = ""
for item in lst:
    result_str += str(item)  # 转换每个元素为字符串并连接

lst = [1, 2, 3, 4, 5]
result_str = ''.join([str(item) for item in lst])

lst = [1, 2, 3, 4, 5]
result_str = ''.join(map(str, lst))

my_tuple = ('apple', 'banana', 'cherry')
my_string = ', '.join(my_tuple)
print(my_string)  # 输出: apple, banana, cherry

my_string = "apple, banana, cherry"
my_list = my_string.split(", ")
print(my_list)  # 输出: ['apple', 'banana', 'cherry']

my_string = "apple, banana, cherry"
my_list = my_string.split(", ")
my_tuple = tuple(my_list)
print(my_tuple)  # 输出: ('apple', 'banana', 'cherry')

a = ['这', '是', '一', '个', '列', '表']	# 创建一个变量名a，这是一个列表

# 内置方法：
# 增加
# 1. append 方法 在列表末尾添加一个元素
# 添加 '这是添加物'
a.append('这是添加物') # 通过append 这个方法 向 变量a 增加了 这是添加物
print(a)	# ['这', '是', '一', '个', '列', '表', '这是添加物']

# 2. insert 方法 在列表指定位置插入元素
# 插入'这是插入物'
a.insert(1, '这是插入物')
print(a)	# ['这', '这是插入物', '是', '一', '个', '列', '表', '这是添加物']

# 3. extend 方法 在列表末尾添加另一个列表的所有元素
# 添加列表
b = ['这', '是', '另', '一', '个', '列', '表']
a.extend(b)
print(a) #['这', '这是插入物', '是', '一', '个', '列', '表', '这是添加物', '这', '是', '另', '一', '个', '列', '表']

a = ['这', '是', '一', '个', '列', '表']	# 创建一个变量名a，这是一个列表
# 删除
# 4. pop 方法 通过索引移除列表中的一个元素（默认最后一个），并返回该元素的值
a.pop(3)
print(a) # ['这', '是', '一', '列', '表']

# 5. remove 方法 通过元素移除列表中的一个元素
a.remove('一')
print(a) #['这', '是', '个', '列', '表']

# 6. clear 方法 移除列表的所有元素
a.clear()
print(a) #[]

a = ['这', '是', '一', '个', '列', '表']	# 创建一个变量名a，这是一个列表
# 7. 直接在对于索引修改用 '='
a[0] = '不'
print(a) #['不', '是', '一', '个', '列', '表']

a = ['这', '是', '一', '个', '列', '表']	# 创建一个变量名a，这是一个列表
# 8. index 方法 返回指定元素在列表第一次出现的索引位置
result = a.index('一')
print(result) # 2

# 9. count 方法 返回指定元素在列表出现的次数
result = a.count('列')
print(result) # 1

a = ['这', '是', '一', '个', '列', '表']	# 创建一个变量名a，这是一个列表
# 10. copy 方法 复制一份变量的内容
result = a.copy()
print(result) # ['这', '是', '一', '个', '列', '表']

# 11. reverse 方法 反转列表的元素
a.reverse()
print(a)  # ['表', '列', '个', '一', '是', '这']

b = [89, 5, 43, 38, 34, 78]	# 创建一个变量名b，存储列表用于排序
# 12. sort方法 从小到大排序列表
b.sort()
print(b) # [5, 34, 38, 43, 78, 89]
# reverse = True 则从大到小 
b.sort(reverse = True)
print(b) # [89, 78, 43, 38, 34, 5]

a = ('这', '是', '一', '个', '元', '组')	# 创建一个变量名a，这是一个元组
# 1. count 方法 返回指定元素在元组出现的次数
result = a.count('列')
print(result) # 1

# 2. index 方法 返回指定元素在元组第一次出现的索引位置
result = a.index('一')
print(result) # 2

# 3. len 方法 返回元组中元素的个数
result = len(a)
print(result) # 6

a = ('这', '是', '一', '个', '元', '组')	# 创建一个变量名a，这是一个元组
b = ('这', '是', '另', '一', '个', '元', '组')	# 创建一个变量名b，这是另一个元组
# 4. 合并两个元组为一个元组
print(a + b) #['这', '是', '一', '个', '元', '组', '这', '是', '另', '一', '个', '元', '组']

# 5. 将元组重复指定次数
print(a * 4) # ['这', '是', '一', '个', '元', '组', '这', '是', '一', '个', '元', '组', '这', '是', '一', '个', '元', '组', '这', '是', '一', '个', '元', '组']

c = (1, 2, 3)	# 创建一个变量名c，1,2,3
# 6. max 方法 返回元组中元素的最大值
print(max(c)) # 3

# 7. min 方法 返回元组中元素的最小值
print(min(c)) # 1

d = '12345'
# 8. tuple 方法 将列表或者其它可迭代对象转成元组
print(tuple(d)) # ('1', '2', '3', '4', '5')

# 1. replace 把对象中有的值放到第一个参数中替换成第二个参数
a = '值1'
b = a.replace('1','2')
print(a) # 值1, 字符串不允许被修改
print(b) # 值2，修改结果存储到新的变量b

# 2. upper 把所有字符串字母改成大写
a = 'asd'
result = a.upper()
print(result) # ASD

# 3. lower 把所有字符串字母改成小写
a = 'ASD'
result = a.lower()
print(result) # asd

# 4. strip 去除字符串首尾指定字符，不传参默认空格
a = 'AsAA'
result = a.strip('A')
print(result) # s

a = '这是一个字符串'	# 创建一个变量名a，这是一个字符串
# 5. count 方法 返回指定元素在字符串出现的次数
result = a.count('一')
print(result) # 1

# 8. find 方法 如果包含子字符串返回开始的索引值，否则返回-1
result = a.find('一')
print(result) # 2

# 7. index 方法 返回指定元素在字符串第一次出现的索引位置，没有则报错
result = a.index('一')
print(result) # 2

# 8. \n 换行
a = '这是一个\n字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一个
       		#字符串
  
# 9.  \t 水平制表符/空格
a = '这是一个\t字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一个	字符串

# 10. \b 退格
a = '这是一个\b字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一字符串

# 11. \r 回车，当前位置回到开头，会把前面整个去掉
a = '这是一个\r字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#字符串

# 12. \\ 反斜杠
a = '这是一个\\字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一个\字符串

# 13. \' 单引号
a = '这是一个\'字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一个'字符串

# 14. \0 空字符
a = '这是一个\0字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一个 字符串

# 15. \a 系统提示音
a = '这是一个\a字符串'	# 创建一个变量名a，这是一个字符串
print(a)	#这是一个字符串

# 16. + 拼接方法
a = '这是'
b = '字符串'

print(a + b) # 这是字符串 

# 17. join 拼接方法
a = ['2023', '12', '02'] # 列表
result = '-'.join(a)
print(result) # 2023-12-02 结果会变为字符串

# 18. format 拼接方法
a = '这是'
b = '一个'
result = '{}{}字符串'.format(a, b) # 插入多个值有顺序关系与{}一一对应
print(result) # 这是一个字符串

# 19. f插值法
a = '这是'
b = '一个'
print(f"{a}{b}字符串") # 这是一个字符串

# 编码
name = "字符串"  # 定义一个变量叫name 存储字符串
encode_result = name.encode("UTF-8")  # 通过encode进行编码为UTF-8
print(encode_result)  # 结果为b'\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2'
# "意味着字符串"在utf8中为\xe5\xad\x97\xe7\xac\xa6\xe4\xb8\xb2,其中b是二进制的意思

# 解码
decode_result = encode_result.decode("UTF-8")
print(decode_result) # 字符串

d = {"字符串2", 1, 2, 3, 2, "字符串1"}
print(d) # {1, 2, 3, '字符串2', '字符串1'}

d = {"字符串2", 1, 2, 3, 2, "字符串1"} # 变量d存储集合
# 1. add 方法 将元素无序添加到集合中去
d.add('添加的字符串')
print(d) # {1, 2, 3, '字符串1', '添加的字符串', '字符串2'}

d = {"字符串2", 1, 2, 3, 2, "字符串1"} # 变量d存储集合
# 2. pop 方法 随机删除一个元素
result = d.pop()
print("被删除的元素是：", result) # 被删除的元素是： 1
print("被删除后的集合结果：", d) # 被删除后的集合结果： {2, 3, '字符串2', '字符串1'}

# 3. remove 方法 删除指定元素，变量a里面没有的元素，就会报错
d.remove(2)
print(d) # {1, 3, '字符串2', '字符串1'}

# 4. update 方法 将另一个集合的元素随机且不重复添加到当前的集合中
d = {"字符串2", 1, 2, 3, 2, "字符串1"} # 变量d存储集合
e = {"另外一个字符串3", "另外一个字符串4", 5, 5, 7, 8} # 变量d存储集合
d.update(e)
print(d) # {1, 2, 3, '字符串1', 5, '另外一个字符串4', 7, 8, '字符串2', '另外一个字符串3'}

# 键值对
a = {
    # 'key' 键 所有的键都要用引号
    # 'value' 值 任意定义
    # 冒号 作用分割 左右两边
    'key1': 'value1',
    'key2': 12
}

# 利用key来取值
print(a['key1'])  #value1

# 键值对
a = {
    # 'key' 键 所有的键都要用引号
    # 'value' 值 任意定义
    # 冒号 作用分割 左右两边
    'key1': 'value1',
    'key2': 12
}

#5. setdefault 有则查，无则增
a.setdefault('key3', 'value2')
print(a) # {'key1': 'value1', 'key2': 12, 'key3': 'value2'} 增加
print(a.setdefault('key2')) # 12 查询

# 键值对
a = {
    # 'key' 键 所有的键都要用引号
    # 'value' 值 任意定义
    # 冒号 作用分割 左右两边
    'key1': 'value1',
    'key2': 12
}

#6. pop 删除指定key的键值对
a.pop('key1') # 删除了变量a中的key1
print(a) # {'key2': 12}

# 7. popitem 返回并删除字典中的最后一对键和值
a.popitem() # 删除了变量a中的key2
print(a) # {'key1': 'value1'}

# 键值对
# 8. update 用于将一个字典中的键值对添加到另一个字典中
a = {
    #  'key' 键 所有的键都要用引号
    #  'value' 值 任意定义
    #  冒号 作用分割 左右两边
    'key1': 'value1',
    'key2': 12
}

b = {
    #  'key' 键 所有的键都要用引号
    #  'value' 值 任意定义
    #  冒号 作用分割 左右两边
    'key3': 'value3'
}

a.update(b) # 将字典b的值update 写到这个变量a中去
print(a) # {'key1': 'value1', 'key2': 12, 'key3': 'value3'}

a = {
    #      'key' 键 所有的键都要用引号
    #      'value' 值 任意定义
    #      冒号 作用分割 左右两边
    'key1': 'value1',
    'key2': 12
}

# 9. get 获取指定key对应的value，如果key不存在返回none
print(a.get('key1')) # value1

# 10. keys 取出所有的key
print(a.keys()) # dict_keys(['key1', 'key2'])

# 11. values 取出所有的values
print(a.values()) # dict_values(['value1', 12])

# 12. items 取出所有完整的键值对
print(a.items()) # dict_items([('key1', 'value1'), ('key2', 12)])

# 创建一个空的冻结集合
f_set = frozenset()

# 从现有集合创建冻结集合
normal_set = {1, 2, 3}
f_set_from_normal = frozenset(normal_set)

# 从其他可迭代对象创建冻结集合
f_set_from_list = frozenset([4, 5, 6])