Python学习笔记之(python数据结构、装饰器及文件操作)

目录

字符串

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)

文件操作

json序列化

总结

上一篇:php – 如何将CKFinder与Laravel集成?


下一篇:学生信息管理---C#文件写入及读取