一、基本输入输出

# input():将所有输入都当作字符串,需要类型转换

num_int = int(input('Please input an int'))
num_float = float(input('Please input a float'))
num_complex = complex(input('Please input a complex'))
container_list = eval(input('Please input a list'))
container_tuple = eval(input('Please input a tuple'))
container_dic = eval(input('Please input a dic'))
container_set = eval(input('Please input a set'))

PRint(num_int)
print(num_float)
print(num_complex)
print(container_list)
print(container_tuple)
print(container_dic)
print(container_set)

# print()

num_int = 233
num_float = 2.6985
num_complex = 2+6j

print(num_int, num_float)                           # 默认空格分隔,回车结尾
print(num_int, num_float, num_complex, sep=',')     # 逗号分隔
print(num_int, num_float, num_complex, end='end')   # end结尾
print(num_int, num_float)

二、数学函数 

import math
# 实数比大小
print(math.isclose(0.4-0.3, 0.1))

# 阶乘
print(math.factorial(32))  # 32的阶乘

# 平方根
print(7**0.5)  # 7的平方根

# 复数运算
c = 3+4j
print(c+c)             # 加
print(c**2)            # 幂运算
print(c.real)          # 查看实部
print(c.imag)          # 查看虚部
print(c.conjugate())   # 查看共轭复数
print(abs(c))          # 计算模

三、容器操作

# 容器定义
x_list = [1, 2, 3]                     # 列表
x_tuple = (1, 2, 3)                    # 元组
x_dict = {'a': 97, 'b': 98, 'c': 99}   # 字典
x_set = {1, 2, 3}                      # 集合

# 容器访问
print(x_list[0], x_list[-1])           # 列表
print(x_tuple[0], x_tuple[-2])         # 元组
print(x_dict['a'])                     # 字典(不安全)
print(x_dict.get('sPEed'))             # 字典(安全),返回None
print(x_set)                           # 集合,是无序的，不能索引

# 元素个数
print(len(x_list))
print(len(x_tuple))
print(len(x_dict))
print(len(x_set))

# 增加元素
x_list = []
x_tuple = ()
x_dic = {}
x_set = set()

x_list.append('list0')                       # 列表,增加在末尾
x_list.insert(0, 'listx')                    # 列表,增加在任意位置

x_tuple = (200, 50)                          # 元组,定义了就不能修改,除非重新定义

x_dic['key'] = 'value'                       # 字典,添加和修改一样

x_set.add('set0')                            # 集合,无序,无需索引
x_set.update({1, 3})
x_set.update([1, 4], [5, 6])

print("After add:")
print("x_list:", x_list)
print("x_tuple:", x_tuple)
print("x_dic:", x_dic)
print("x_set:", x_set)

# 删除元素
x_list = ['list0', 'list1', 'list2', 'list3']
x_tuple = ('tuple0', 'tuple1', 'tuple2', 'tuple3')
x_dic = {'dic0': 0, 'dic1': 1, 'dic2': 2, 'dic3': 3, 'key': 'value'}
x_set = {'set0', 'set1', 'set2', 'set3', 'set4'}

del x_list[0]                                # 列表,删除0号位置
x_list.remove('list3')                       # 列表,删除值为list3的元素
popped_element = x_list.pop(1)               # 列表,弹出1号位置的元素,并赋给变量

# 元组,不可修改

del x_dic['key']                             # 字典,删除名称为key的键值对

x_set.remove('set2')                         # 集合(不安全),删除名为set2的元素
x_set.discard('set2')                        # 集合(安全),不存在不会发生错误
x_set.pop()                                  # 集合(随机删除一个元素)

print("nAfter delete:")
print("x_list:", x_list)
print("x_tuple:", x_tuple)
print("x_dic:", x_dic)
print("x_set:", x_set)

# 清空or删除容器
x_list.clear()                              # 清空列表
del x_list                                  # 删除列表

# 元组不可修改
del x_tuple                                 # 删除元组

x_dic.clear()                               # 清空字典
del x_dic                                   # 删除字典

x_set.clear()                               # 清空集合
del x_set                                   # 删除集合

四、类型转换

# int()

# 实数->整数
print(int(3.5))                 # 获取实数的整数部分

# 字符串->整数
print(int('119'))               # 把整数字符串转换为整数
print(int('  9n'))             # 自动忽略字符串两个的空白字符

# 进制转换
print(int('1111', 2))           # 把1111看作二进制数，转换为十进制数
print(int('1111', 8))           # 把1111看作八进制数，转换为十进制数
print(int('1111', 16))          # 把1111看作十六进制数，转换为十进制数

#float()、complex()

# 字符串->浮点数
print(float('3.1415926'))       # 把字符串转换为实数
print(float('-inf'))            # 负无穷大

# 产生复数
print(complex(3, 4))            # 复数
print(complex(6j))
print(complex('3'))

# bin()、oct()、hex()

# 进制转换
print(bin(8888))              # 把整数转换为二进制
print(oct(8888))              # 把整数转换为八进制
print(hex(8888))              # 把整数转换为十六进制

# ord()、chr()、str()

# ASCII or Unicode 字码转换
print(ord('a'))               # 返回字符的ASCII码
print(chr(65))                # 返回指定ASCII码对应的字符
print(ord('董'))              # 返回汉字字符的Unicode编码
print(chr(33891))             # 返回指定Unicode编码对应的汉字

# 容器->字符串
print(str([1, 2, 3, 4]))      # 把列表转换为字符串
print(str({1, 2, 3, 4}))      # 把集合转换为字符串

# list()、tuple()、dict()、set()

# 集合->列表or元组
s = {3, 2, 1, 4}
print(list(s))
print(tuple(s))

# 列表->元组or集合
lst = [1, 1, 2, 2, 3, 4]
print(tuple(lst))
print(set(lst))  # 自动去重

# 字符串->列表
print(str(lst))  # 包括[],逐字符插入
print(list(str(lst)))
print(tuple(str(lst)))
print(set(str(lst)))

# 键值对->字典
print(dict(name='Dong', sex=';male', age=41))

五、字符串操作

【Python】字符串，数，运算符_fftx_00的博客-CSDN博客

六、max(),min()

data = [3, 22, 111]
print(data)
# 列表,比较大小,最大or小元素
print(max(data))
print(min(data))

# 列表,转换为字符串后,表中最大单个字符
data = [3, 22, 111]
print(max(data, key=str))
# 列表,转换为字符串全小写后,表中最大单个字符
data = ['abc', 'Abcd', 'ab']
print(max(data, key=str.lower))

# 字符串列表,表中最长字符串
data = ['3', '22', '111']
print(max(data, key=len))
# 字符串列表,表中最大字符串
data = ['abc', 'Abcd', 'ab']
print(max(data))

# 列表,表中出现次数最多的元素
data = [1, 1, 1, 2, 2, 1, 3, 1]
print(max(set(data), key=data.count))  # 也可以使用标准库collections中的Counter类实现
# 列表,表中最大元素的位置，列表方法__getITem__()用于获取指定位置的值
print(max(range(len(data)), key=data.__getitem__))

七、len(),sum()

# len():容器中元素的个数
# sum():容器中所有元素之和
data = [1, 2, 3, 4]
print(len(data))
print(sum(data))
data = (1, 2, 3)
print(len(data))
print(sum(data))
data = {1, 2, 3}
print(len(data))
print(sum(data))
data = 'Readability counts.'
print(len(data))                     # 字符串长度
data = {1: 'a', 2: 'b', 3: 'c'}
print(len(data))                     # 键个数
print(sum(data))                     # 所有键相加

 八、sorted(),reversed()

# sorted():  临时升序排序

From random import shuffle
data = list(range(20))
shuffle(data)                  # 随机打乱顺序
print(data)
print(sorted(data))            # 升序排序

print(sorted(data, key=str))                 # 按转换成字符串后的大小升序排序
print(sorted(data, key=str, reverse=True))    # 按转换成字符串后的大小降序排序

# reversed():临时逆转容器顺序
# 惰性求值,生成逆转对象只能使用一次,
# 不支持使用内置函数len()计算元素个数,不支持使用内置函数reversed()再次翻转

from random import shuffle
data = list(range(20))         # 创建列表
shuffle(data)                  # 随机打乱顺序
print(data)

reversedData = reversed(data)  # 生成reversed对象
print(list(reversedData))      # 根据reversed对象得到列表
print(tuple(reversedData))     # 空元组，reversed对象中元素只能使用一次

九、range()

# range(start, stop, step)生成数值列表

range1 = range(4)           # 只指定stop为4，start默认为0，step默认为1
range2 = range(5, 8)        # 指定start=5和stop=8，step默认为1
range3 = range(3, 20, 4)    # 指定start=3、stop=20和step=4
range4 = range(20, 0, -3)   # step也可以是负数

十、zip()

zip() 函数用于将可迭代的对象作为参数，将对象中对应位置的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

我们可以使用 list() 转换来输出列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

 十一、map()

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

十二、reduce()

reduce() 函数会对参数序列中元素进行累积。

函数将一个数据集合（链表，元组等）中的所有数据进行下列操作F1a;用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

 

 

十三、filter()

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。