目录
字符串
Python3中统一采用Unicode编码，也封装了字符串类str
mystr = 'RoyKun'
result = mystr.index('R') # 获取字符索引，没找到会崩溃
print(result) # 0
result = mystr.find('K') # 获取字符索引，如果没找到返回-1
print(result) # 3 区分大小写哦！
result = mystr.count('u') # 字符出现的个数
print(result) # 1
result = len(mystr) # 返回字符串长度
print(result) # 6
result = mystr.replace('u','n') # 字符替换
print(result) # RoyKnn
print(mystr) # RoyKun
mystr = 'apple,pear,orange'
result = mystr.split(',') # 分割数据
print(result) # ['apple', 'pear', 'orange'] 得到列表
mystr = 'aabccb'
result = mystr.partition('b')# 以指定字符串分割为3部分
print(result) # ('aa', 'b', 'ccb') 得到元祖，只会以第一个 , 分割
myurl = 'http://www.baidu.com'
result = myurl.startswith('http') # 是否以指定数据开头
print(result) # True
myurl = 'http://www.baidu.com'
result = myurl.endswith('xxx') # 是否以指定数据开头
print(result) # False
mystr = 'k'
result = mystr.join('Roy') # 以指定字符串拼接数据
print(result) # Rkoky
mystr = mystr +'Roy'
print(mystr ) # kRoy
mystr = ' Roy '
result = mystr.strip(' ') # Roy 去除两边指定字符
# result = mystr.lstrip(' ')
# result = mystr.rstrip(' ')
print(result)
注意有些是引用，直接操作；有些会返回新的对象
常见数据类型及操作
列表
# 列表：以中括号表现形式的数据集合，可以放任意类型的数据
# 因此，列表本质是一个指针数组
my_list = [1, 'app', True]
print(type(my_list)) # <class 'list'>
print(my_list[-2]) # app
my_list.append('Roy') # 追加数据
my_list.insert(1, 'kun') # 指定位置插入数据 [1, 'kun', 'app', True, 'Roy']
mylist2 = ['watermelon', '草莓']
my_list.extend(mylist2) # 添加列表元素（扩展）
print(my_list) # [1, 'app', True, 'watermelon', '草莓']
my_list.remove('草莓') # 删除指定元素
del my_list[0] # 根据下标删除元素 ['app', True, 'watermelon']
result = my_list.pop(1) # 删除数据并返回数据值，如果不传参 默认删除 -1 位置
# 即 list默认是个栈，后进先出
print(result)
# 列表生成式
my_list = [value for value in range(1,6)]
print(my_list) # [1, 2, 3, 4, 5] 包头不包尾
my_list = [value+"Hello" for value in ['ab','abc']]
print(my_list)
my_list = [(x,y) for x in range(1,3) for y in range(2,4)] # range包头不包尾
print(my_list) # [(1, 2), (1, 3), (2, 2), (2, 3)] 等价于两层for循环
元祖
# 元祖：以小括号形式表现的数据集合，可以存任意类型的数据
# 不能对元祖进行数据修改
my_tuple = (1, 2, 'Roy',[3,4])
print(my_tuple)
# my_tuple[0] = 2 # 不能直接修改
# TypeError: 'tuple' object does not support item assignment
my_tuple[3].append(5)
print(my_tuple) # (1, 2, 'Roy', [3, 4, 5])
# 如果存储的元素本身是可变的，那可以改变这个元素
# 如果只有一个元素需要添加逗号，不然会判断为其他类型
my_tuple2 = (1,)
print(type(my_tuple2)) # <class 'tuple'>
my_tuple2 = (1) # <class 'int'>
字典
# 字典：以大括号形式表现的数据集合，元素使用键值对表示
# 字典中的数据是无序的（输出顺序不定）
my_dict = {'name':'Roy', 'age':18, 'hobby':'fuck'}
print(my_dict)
result = my_dict.pop('age') # 删除元素，必须指定key
# 使用dict函数
dict2 = dict(a='a', b='b', t='t') # 一般传入的是可迭代对象
print(dict2)
dict(zip(['one', 'two', 'three'], [1, 2, 3]))
dict([('one', 1), ('two', 2), ('three', 3)])
集合
# 集合set：以大括号表示的数据集合，无序，且不能重复
my_set = {1, 2, 'Roy'}
print(type(my_set)) # <class 'set'>
my_set.remove(1) # 删除指定元素，元素必须存在否则报错
print(my_set)
my_set.discard('Roy') # 不报错
print(my_set)
my_set2 = set() # 若没有元素时
print(type(my_set2)) # <class 'set'>
my_set2.add('666')
print(my_set2)
# 无序，也就是说不能根据下标进行操作
字典和集合都用大括号=={ }==
列表、元祖、集合都叫做数据容器，可以相互转换
my_list = [1,2,2]
my_tuple = (4,5)
my_set = {'name', 'age'}
# 列表转集合
result = set(my_list) # 会对元素去重
# 元祖转集合
result = set(my_tuple)
# 列表转元祖
result = tuple(my_list)
# 集合转元祖
result = tuple(my_set)
# 集合转列表
result = list(my_set)
# 元祖转列表
result = list(my_tuple)
enumerate()函数用于将一个可遍历的数据对象(如元组、列表、集合或字符串)组合为一个索引序列
也是后面拆包的常用操作
for index, value in enumerate(['apple', 'banana']):
print(index,value) # 在命令行执行要加空格
# 0 apple 加序号
# 1 banana
针对字典可以使用 item() 方法迭代
# 针对字典
my_dict = {'name':'Roy', 'age':18, 'hobby':'fuck'}
for key, value in my_dict.items(): # 这个就是key，而不是序号
print(key,value)
for keys in my_dict.keys(): # 当然，还有keys()方法
print(keys)
字典、列表、字符串是最常见的数据结构，且都是可迭代对象，后面会介绍迭代器
函数相关操作
函数传参
# 不定长参数函数
def fun(a, b, *args, **kwargs):# a,b是必传参数
print(a)
print(b)
print(args)
print(kwargs)
fun(1, 2, 3, 4, name = "hello", age = 20)
# 1
# 2
# (3, 4) 元祖封装
# {'name': 'hello', 'age': 20} 字典封装
fun(1, 2, 3, 4, name = "hello", age = 20, 18) # SyntaxError: positional argument follows keyword argument 语法错误，参数位置不正确
递归函数
# 递归函数：传递回归，即在函数内部再次调用函数
def cal_num(num): # 计算阶乘
if not isinstance(num, int):
return 'error input'
if num == 1: # 结束递归的条件（递归出口）
return 1
else:
return num * cal_num(num-1)
cal_num(5)
import sys
result = sys.getrecursionlimit() # 获取最大递归次数
print(result) # 1000
sys.setrecursionlimit(1100) # 设置最大递归次数
程序本质上就是：循环、判断、递归
匿名函数
# 匿名函数：没有名称的函数
# 由于这个函数只在这里用一下，所以没有必要单独定义，可以简化代码
# func接收函数即可，需要传递函数作为参数时，直接写lambda表达式即可
func = lambda x,y: x+y # 前面是参数；后面只能写一句表达式，返回计算结果
result = func(2,4)
print(result)
func1 = lambda num: True if num%2 == 0 else False # 判断奇偶 T要大写，放在前面！
print(func1(5))
list2 = [{'name':'roy','age':22},{'name':'kun','age':20}] # 对字典列表进行排序
list2.sort(key=lambda item: item['age']) # key= reverse= 是关键字
# 默认False，升序！
print(list2) # item代表列表中的每个字典，sort函数内部循环获取所有age值排序
语法就记一下吧：简单运算、bool判断、排序（传递关键字）
高阶函数
装饰器
闭包：是高级函数
# 函数嵌套时，内部函数使用外部函数的参数或变量，最终返回这个内部函数，叫做闭包
def exfunc(msg,num):
def refunc():
print(msg*num)
return refunc # 注意不带括号
# 闭包的好处是可以根据参数得到新函数，从而适应不同需求
func = exfunc('roy',2)
func() # royroy
print(func) # <function exfunc.<locals>.refunc at 0x000002572A4AFE58>
装饰器：函数引用指向原函数，原函数名接收闭包，实现功能扩展
# 装饰器本质上是一个函数，可以对原函数的功能进行扩展，不影响原函数的定义和调用
# 装饰器的实现要用到闭包
# 通用装饰器：可以修饰带参数的和不带参数的函数，有返回值的和无返回值的函数
def decorator(func): # 最外层，传递函数名
def inner(*args, **kwargs): # 内层，接收原函数参数
print('这是对被装饰函数扩展的操作') # 扩展部分
return func(*args, **kwargs) # 需要设置原函数的参数，对于有返回值的函数需要return；总之，加上是没错的！
return inner
# 上面是两层装饰器，如果装饰器也带参数呢？就需要三层
@decorator # 语法糖，相当于执行 sum = decorator(sum) 接收闭包，扩展了原函数
def sum(num1,num2):
print(num1 + num2)
sum(1,3) # 这是对被装饰函数扩展的操作
@decorator
def test():
print('Roy')
test() # 这里函数不带有参数
切片（取元素）
# 针对字符串，类似numpy的矩阵操作
str = 'RoyKun'
result = str[0:5:1] # 起始下标：结束下标：步长 （不包含结束下标）
print(result) # RoyKu
result = str[-1:-4:-1] # nuK
print(result)