输出的方式：

print(f'abscwdasd {num}')
print('asbduwiu %d', a)
print('asnidoian %d %d %d',a,b,c)

不换行

print('asbdiuabw',end = '')

输入

a = input('输入')
只能输入字符串形式，如果相当做数字用则将其转化为数字
只有合法的数字才能转化成功
a = int(input())

数据类型：

int:1  2
float:1,3  3,2
str: 'asdas'
complex: 1 + 3j
bool: True,False
None

字符串的定义和加减

def:

string = """
ajsejneakje
wadsjdk
"""

string = 'asdubw'

string = "asdbwkiankd"

±

string1 = 'abc'
string2 = 'def'

string3 = string1 + string2
string3 == 'abcdef'

语句

判断：

if a > b:
	......
elif a < b:
	......
else :
	......

循环：

for循环

for i in str:
	print(i)

for i in range(a,b):	# 从a到b-1
	print(i)

for i in range(a):		# 从0到a-1
	print(i)

for i in range(a,b,c):	# 从a到b-1，并且每次加c
	print(i)

while循环

while 条件:
	......

数据容器

在python的数据容器中，有序代表着按照预定顺序插入，并且能够通过索引访问，支持切片操作等，这里的有序并非是自动排序的意思。

List

def:

lst = [1,2,3,4,5] #  定义出一开始就有元素的

# 定义空列表
lst = []
lst = list()

# 定义二维
lst = [[1,2,3],['a','b','c'],[1+1j,1+2j,1+3j]]

值得注意的是，python中的List列表是可以同时存储多种数据类型的

ex:
lst = [1,True,'asdbwiau',None,1 + 3j]

输出

print(lst)	# 这样输出会带着'[ ]'
for i in lst:	# 即遍历输出
	print(i)

# 使用for循环进行下标遍历
for i in range(len(lst)):
	print(lst[i])

下标与数组类似，即从0开始，使用下标取出元素lst[2]
但是List的下标可以反向，即最后一个元素的下标作为-1，倒数第二个为-2

二维的下标访问方式可以类比数组

并且List是有序的

List自带的方法

查询下标：lst.index(元素)，即查询询问元素的下标，找不到会报错

直接对相应下标修改：lst[i] = a，直接操作没什么好说的

插入操作：lst.insert(id,value)，传入下标和元素，在指定下标位置插入指定元素，插入的时候，会把当前在id下标的元素以及之后的元素往后挤

插入尾部：lst.append(value)，在列表的最后插入一个元素
将其他列表插入尾部：lst.extend([1,2,3])

删除元素:del lst[id]，删除下标为id位置的元素，以及lst.pop(id)，删完之后，id下标之后的所有元素往前走

删除指定元素：lst.remove(value)，传入值，删除列表中第一个指定的值

清空列表：lst.clear()

统计某元素在列表中的数量：lst.count(value)，返回value元素在列表中的数量

返回列表长度（元素数量）：len(lst)

Tuple元组

Tuple是不可被修改的

def:

tup = (1,2,3)

tup = ()
tup = tuple()

# 定义一个元素的时候，必须要加一个逗号，不然不会被定义为tuple类型
tup = (1,)

同样可以定义二维且能够通过下标访问

Tuple是有序的

tuple的方法

仅有index(),count(),len(tup)三个方法，使用方式与List类似

str字符串

和C的char数组类似的原理

可以通过下标访问字符
但是需要注意python的字符串是不能通过任何方式（函数或下标操作）进行修改的

并且注意python中的字符串比较是一位位比较，就算长度不一样也是严格按照位数进行比较，例如'aaa'就小于'ab'

str的方法

查找元素的下标：string.index('abc')，会返回找到的第一个'and'中的'a'的下标

修改字符串：new_string = string.replace(string1,string2)，将string中的所有字符串string1替换为string2，但是该操作会得到一个新的字符串，并不会修改字符串本身

分割字符串：string.split(分隔符字符串)，按照给定的分割符字符串，将字符串划分为多个字符串，并存入列表List中，这个方法会返回一个List类型，分割字符串不会被包括进去

去掉前后空格操作：string.strip()，也是得到新的字符串

去掉指定字符串：string.strip(string1)，去掉string中的所有不论顺序的包括string1中的字符的子字符串

统计字符串个数：string.count(string1)

统计长度：len(string)

￥# 序列类型数据结构的切片操作
序列[启始下标:结束下标:步长]
步长不写既为1，从启始下标取到结束下标-1
不写启始与结束下标，就是整个复制，在加上步长，就是从头到尾按照步长来取

如果步长为负数，那么就是倒着取，可以实现反转序列

实现反转后取元素操作如下：

string[::-1][1:5]

set集合

set不能存储重复元素，并且无序，可以实现自动去重
由于set无序，所以不能够使用下标进行查找元素

def:

s = {1,2,3}

# 空集合
s = set()

set的方法

插入新元素：s.add(value)，添加指定元素

移除元素：s.remove(value)，移除指定元素

弹出元素：s.pop()，随机取出一个元素（返回该元素），并且从集合中将其移除

清空集合：s.clear()

取两个集合的差集：s = s1.difference(s2)，取集合1和集合2的差集赋给集合s，即取出集合1中有且集合2中没有的

删除两个集合的交集：s1.difference_update(s2)，在集合1内，删除和集合2相同的元素，这个方法会修改集合1

合并两个集合：s = s1.union(s2)，合并集合1和集合2，返回给集合s

计算集合数量：len(s)

集合的遍历只能够使用for的形式进行

for i in s:
	print(i,end = '')

dict字典

可以类比C++中的map，即每个键对应一个值

def:

d = {key:value,key:value}

# 定义空字典
d = {}
d = dict()

如果有重复的键，那么前面的键值对会被后面的键值对覆盖

不支持下标访问，可以直接通过key值访问：dic[key]

并且字典支持嵌套：d = {key :{key2 :value,key3:value}}

dict的方法

添加元素：dic[key] = value，直接赋值，类比C++map，如果key之前出现过，那么就直接覆盖为value

删除元素：dic.pop(key)，返回给定的key对应的value，并且从字典中移除这个键值对

清空字典：dis.clear()

获取全部的key：dic.keys()，可以用变量接收，返回字典中全部的键，在遍历字典的时候也要通过这个方法，即取出全部key之后遍历所有key然后通过key求出对应的所有value

同时也可以直接遍历字典，这样取出的是字典的key值

统计字典元素个数：len(dic)

所有数据容器的通用方法

len(容器)，求长度（元素个数）
max(容器)，求容器中最大值
min(容器)，求容器中最小值
list(容器)，将给定容器转化为列表
str(容器),将给定容器转化为字符串
tuple(容器),将给定容器转化为元组
set(容器)，将给定容器转化为集合

sorted(容器,[reverse = True])，将容器进行排序，sorted(容器)表示正向排序，sorted(容器,reverse = True)表示反向排序
如果对字典进行排序会丢失value

函数：

定义：

def 名称（传入参数）:
	语句

关键字

return 数据类型

global 变量名 # 把全局变量声明，不然直接定义的话就会被当成一个和全局变量同一个名字的局部变量

python的函数支持多个返回值：return 1,2，并且返回值的数据类型可以为任意

def func():
	return 1,2
# 也需要多个变量进行接收
a,b = func()

传入参数方式

1.可以按照顺序直接传参数，和其他语言一样
2.关键字传参，通过关键字 = value来指定参数

def func(value1,value2,value3):
	print(value1,value2,value3)

func(value1 = 1,value2 = 2,value3 = 3)

这种传参方式不需要严格按照函数给定的顺序传参
3.缺省参数，使用默认参数，在定义函数的时候就给定，如果不再次给定这个参数的值，那么就会保持这个默认值，否则直接覆盖

def func(value1,value2,value3 = 3):
	print(value1)
func(1,2)

4.不定长参数，也叫可变参数，如果不确定参数个数就用不定长参数，有位置传递和关键字传递的方法

# 位置传递
def func(*args):
	print(args)

可以传入任意数量的参数给args，传入的所有参数会被合并为一个元组（tuple），即args是元组类型

# 关键字传递
def func(**kwargs):
	print(kwargs)

func(value1 = 1,value2 = 2,value3 = 3)

会根据key = value的方式构建出字典，构建的时候会根据写入的值自动匹配数据类型

匿名函数

函数作为参数

不要理解错，python中函数的编写前后关系不会影响是否能够调用
对于一个想要调用其他函数的函数，可以在参数中写上函数的名字，这样就能够传入一个函数

lambda函数

lambda匿名函数不可重复调用

def：

lambda 传入参数:......（函数体，且只能为一行代码）

ex:
a = 1
b = 1

def func(f):
    print(f(a,b))

func(lambda a,b:a+b)

# 结果
2