python函数总结

系统函数

1. print 输出
2. input 输入
3. type 查看数据类型
4. del 删除
5. int 整型
6. str 字符串
7. float 浮点型
8. ord 查看字符对应的整数
9. chr 查看整字对应字符
10. pow 求幂
11. divmod 求商和余数
12. abs求绝对值
13. range 产生特殊序列的对象
14. enmerate 枚举对象
15. counter 统计元素及次数
16. round 四舍五入
17. max 求最大值
18. min 求最小值
19. sum 求一个序列所有元素的和
20. format 占位函数
21. len 可以统计字符串的长度

列表函数

1. append 在列表末尾添加一个元素

2. insert 在指定下标添加个一新的元素，不覆盖原数据，原数据向后延申

3. index 查找列表中元素第一次出现的下标

4. extand 将序列中的元素添加到列表

5. remove 删除列表中的指定元素

6. del 根据下标删除列表中的元素

7. reverse 将列表逆序

8. sort 将列表升序排列

9. pop 弹出并删除列表中的元素,默认最后一个,可以指定下标

10. count 统计元素出现的个数

11. enumerate 列举

12. enumerate 遍历列表，同时给出下标和值

13. range 生成一个列表

集合的函数

1. add 添加一个元素
2. remove 删除元素 不存在会报错
3. discard 删除元素, 不存在不会报错
4. pop 随机弹出一个元素,并删除
5. union 并集
6. intersection 交集
7. difference 差集
8. isdisjoint 判断是否有交集
9. issubset 判断是否是子集
10. insuperset 判断是否是父集
11. clear 清空元素
12. abs 绝对值

字典的函数

1. get 通过键,获取值,不存在返回None,可以指定默认值
2. update 添加键值对,存在的就覆盖,不存在就添加
3. setdefault 键存在就返回对应值，不存在先添加，再返回。值默认值None，可以指定
4. popitems 随机弹出并返回一个键值对，一般是末尾的元素，字典为空会报错
5. pop 删除指定的键，并返回值，一般是末尾的元素，没有会报错。
6. items 返回字典的所有键值对组成（每个键值对是一个元素）列表，可以遍历，转换

字符串的函数

1. splitlines 按照换行进行切割
2. split 按照指定内容进行切割
3. join 拼接字符串
4. find 查找字符串的某个内容出现的次数
5. rfind 从右边开始查找出现的次数
6. count 统计字符串出现的次数
7. startwith 判断字符串是否以指定内容开头
8. endwith 判断是否以指定内容结尾
9. upper 全部转为大写
10. lower 全部转为小写
11. swapcase 大小写互换
12. capitalize 首字母大写
13. title 每个单词首字母大写
14. replace 替换指定内容
15. isupper 判断是否全是小写
16. isdecimal 判断是否全是数字
17. istitle 判断是否每个单词首字母都大写
18. isalpha 判断是否群是字母
19. isalnum 判断是否全是数字或字母
20. isidentifier 判断是否是合理的标识符
21. ljust 左对齐，右侧填充指定内容，默认填充空格
22. rjust 右对齐，左侧填充指定内容，默认填充空格
23. center 居中对齐，两边填充指定内容，默认填充空格
24. strip 同时去除两边的指定内容的字符串
25. lstrip 去除左边的指定内容的字符
26. rstrip 去除左边的指定内容的字符

函数

1. return 返回
2. args **kwargs 接收多余参数args 返回的是元祖，接收有属性的参数**kwargs 返回的是字典

变量的作用域

1. global 修改全局变量，声明函数
2. nonlocal 内部函数修改外部函数变量，声明函数

匿名函数

1. lambda 匿名函数，用于简单函数的使用

装饰器

1. @装饰器函数

函数判断

isfunction 判断对象是否是函数 from inspect import isfunction
callable 判断函数是否可以调用

生成器

1. yield 返回yield后面的值，然后停止在这里
2. next 从生成器里提取元素

迭代器

1. Iterable 判断一个对象是否是可迭代对象 from collections import Iterable #isinstance(lt, Iterable)
2. Iterator 判断一个对象是否是迭代器 from collections import Iterato #isinstance(lt, Iterator)
3. iter 可以将迭代对象转为迭代器

高阶函数

1. map 用func依次作用于iter1的每一个元素，返回一个迭代器
2. filter 使用function依次作用于iterable中的每个元素中，返回值为真的元素保留下来
3. reduce 使用function函数做用于sequence序列中的元素，得到的结果与下一个元素再次使用function处理， 最终得到一个结果，然后返回 from functools import reduce
4. sorted 排序函数，支持升序降序，还支持任意类型的排序，返回的排序后的新列表，原列表保持不变

数学模块 math

1. math.pi 打印Π
2. math.e 打印一个常量
3. math.ceil 向上取整
4. math.floor 向下取整
5. math.sqrt 求x平方根
6. math.radians 把角度下转换为弧度 360 = 2Π
7. math.degrees(math.pi) 把x从弧度转换成角度 一个Π是180度

随机模块 random

1. random.randint 生成指定范围内的随机整数
2. random.uniform 生成指定范围内的随机小数
3. random.random 生成0-1的随机小数
4. random.choice 从容器对象中随机挑取一个元素
5. random.sample 从容器对象中随机挑取指定个数的元素，返回一个列表
6. random.choices 从容器对象中挑选一个元素，返回一个列表,相当于sample提取个数为1的情况
7. random.shuffle 打乱列表的元素的顺序

系统模块

1. sys.argv 保存所有的命令行参数
2. sys.platform 系统平台

os模块

1. os.system(‘cls’) 清空屏幕
2. os.system(‘calc’) 出计算器
3. os.name 查看系统类型

os模块目录操作

1. os.getcwd() 查看当前工作目录
2. os.mkdir(‘test’) 创建目录,默认当前目录,可以指定目录,不能创建中间目录 os.mkdir(‘test/c/练习’)
3. os.makedirs(‘a/b/c’) 可以创建中间目录
4. os.rmdir(‘test’) 删除目录,只能删除空目录
5. os.rename() 修改名称,可以修改文件名,也可以修改目录名,(old,new)
6. os.listdir() 查看目录信息
7. os.stat() 查看文件信息
8. os.stat(‘os模块.py’).st_size 获取指定属性 字节
9. os.remove 删除文件

os模块中path的操作

1. path.join(‘abc/def/’,‘hello.py’) 目录拼接：目录分隔符会自动处理
2. ath.dirname(‘abc/def/hello.py’) 目录提取,提取文件的上层目录
3. ath.basename(os.getcwd()) 取文件名
4. dir_name, file_name = path.split(‘abc/def/hello.py’ 切割文件名与路径
5. file_name, ext = path.splitext(‘hello.py’) 切割文件名与后缀
6. path.exists(‘aa’) 判断文件是否存在
7. path.isfile() 判断是否是普通文件
8. path.isbd() 判断是否是绝对路径
9. path.isdir() 判断是否是目录
10. path.getsize() 获取大小，仅限文件

文件读写的函数

1. open 打开文件
2. read 读取文件
3. write 写入文件
4. close 关闭文件
5. readable 判断文件是否可读
6. writeable 判断文件是否可写

字节流

1. encode 编码
2. decode 解码

环境变量

1. set 设置环境变量 名称=值 获取 set 名称
2. os.environ[ ] 获取指定环境变量，不存在会报错
3. os.environ.get() 存在则返回对应的值，不存在则返回默认值
4. os.getenv() 是os.environ.get()它的简写形式

shutil库

1. shutil.copy() 拷贝文件
2. shutil.copy() 拷贝目录
3. shutil.rmtree 删除目录
4. shutil.move 移动文件或目录

time时间模块

1. time.sleep() 设置睡眠的秒数
2. time.time() 获取当前时间戳
3. time.locktime() 将时间戳转换为时间对象,时间带时区
4. time.gmtime() 将时间转为时间对象，不带时区
5. time.timezone() 0时区与当地时区的时间差（秒数）
6. time.mktime(()) 将时间信息转换为时间戳
7. time.strtime(’%Y-%m-%d %H:%M:%S %w %w’,local_time) 时间格式化显示，%Y：年(4位) %y：年(2位) %m：月 %d：日 %D：月/日/年 %H：时 %M：分 %S：秒 %w：星期几(1~7) %W：本周是今年的第几周

calendar日历模块

calendar.calendar() 返回某一年的日历 w:显示星期的字符数 l:内容的行高 c:两个月的水平间隔

calendar.month() 返回某个月的日历，指定年和月

calendar.issleap() 判断是否是闰年 import calendar

calendar.leapdays() 获取两个闰年之间的数量，[起始年份，结束年份）

datetime日期时间模块

date() 指定年月日 from datetime import date

date.today() 表示今天的日期

d = date.fromtimestamp() 根据时间戳创建日期

d.year, d.month, d).day 单独提取年月日信息

d.timetuple 将date转换为time.struct_time time.struct_time(tm_year=2019, tm_mon=3, tm_mday=21, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=80, tm_isdst=-1)

d.isoweekday() 获取星期几，格式：1-7

d.weekday() 获取星期:0-6

d.isoformat() 标准格式

d.issocalendar() 日历显示:(年,月,日,星期)

d.strftime(’%Y//%m//%d‘) 格式化显示

t = time(11,22,33) 创建时间对象 from datetime import time

t.hour,t.minute,t.second 单独获取时分秒

t.strftime(’%H-%M-%S’) 格式化显示

dt = datetime(2019,3,21,22,28,20) 时间日期datetime from datetime import datetime

dt.timestamp(） 转换为时间戳 dt.strftime(’%Y/%m/%d %H:%M:%S’) 格式化显示

datetime.utcnow() 当前时间,不带时区

datetime.fromtimestamp(time.time()) 根据时间戳进行转换

d = dt.date() 提取日期 dt.time() 提取时间

时间间隔timedelta

from datetime import datetime,timedelta
d1 = datetime(2019,3,11,14,19,56)
d2 = datetime(2019,3,1,15,30,25)

delta = d2 - d1
print(delta, type(delta))

# 查看相差的天数
print(delta.days)

# 查看相差的除天以外的秒数
print(delta.seconds)

# 查看的相差的总共的秒数
print(delta.total_seconds())

# 创建时间相差对象
delta2 = timedelta(days=0,seconds=10)
# 运算后得到一个新的对象
d3 = d1 + delta2

虚拟环境

# 为什么要使用虚拟环境？
# 在一个环境中不同软件依赖同一包的不同版本，为了进行环境隔离就出现了虚拟环境。
# 安装工具：virtualenv
# pip install virtualenv
# 创建虚拟环境：
# virtualenv 虚拟环境目录
# 启动虚拟环境：
# 虚拟环境目录\Scripts\activate.bat
# 退出虚拟环境：
# 虚拟环境目录\Scripts\deactivate.bat
# 快速复制一个虚拟环境：
# 冷藏要复制的环境：pip freeze > requirements.txt
# 创建新的虚拟环境：virtualenv 虚拟环境名
# 激活虚拟环境：虚拟环境目录\Scripts\activate.bat
# 安装依赖：pip install -r requirements.txt
# 虚拟环境管理：virtualenvwrapper-win
# 安装：pip install virtualenvwrapper-win
# 说明：通过系统环境变量WORKON_HOME设置虚拟环境存放目录，默认保存在C:\Users\用户名\Envs
# 查看：lsvirtualenv
# 创建：mkvirtualenv
# 删除：rmvirtualenv
# 启动：workon 虚拟环境
# 退出：deactivate.bat

面向对象

self 哪个对象调用就代表谁

str__ 没有重写此方法，默认打印对象的类名加地址 重写此方法，打印对象会打印该方法的返回值

init 构造方法：创建对象后系统会自动调用该方法完成初始化设置

init 析构方法 ：当对象释放时，系统会自动调用 用于资源释放操作，如：断开数据链接，关闭文件等

常用内置函数 获取属性时

# 说明：内置函数在特定时机被系统自动调用，不需要进行手动调用
# 设置、获取、删除属性时会自动触发的函数

class Person:
    def __init__(self,name):
        self.name = name
    # 访问不存在的属性自动触发
    def __getattr__(self, item):
        #ietm：获取不存在的属性名
        print(item)
        if item == 'age':
            return 10
        elif item == 'weight':
            return 60
        return '你猜'
    # 设置属性时自动触发
    def __setattr__(self, key, value):
        #key：表示属性名，value表示属性值
        # print(key,value)
        #手动保存
        self.__dict__[key] = value
    # 删除对象属性时自动触发
    def __delattr__(self, item):
        print(item,'属性即将销毁')
        del self.__dict__[item]

xiaohuang = Person('小黄')
# print(xiaohuang.age)
# print(xiaohuang.weight)
# print(xiaohuang.height)

# 设置属性
xiaohuang.age = 18
print(xiaohuang.age)
print(xiaohuang.name)

# 存放所有的对象属性
print(xiaohuang.__dict__)

del xiaohuang.name
print(xiaohuang.name)

常用内置函数 当作字典时

# 把对象当作字典时，会自动触发相关函数
class Person:
    #将对象当作字典，添加或设置属性时
    def __setitem__(self, key, value):
        # print(key,value)
        self.__dict__[key] = value
    # 将对象当作字典操作，获取属性时
    def __getitem__(self, item):
         # print(item)
         return self.__dict__.get(item)
    #将对象当作字典操作，删除属性时
    def __delitem__(self, key):
        print(key,'即将销毁')
        del self.__dict__[key]


xixi = Person()
xixi['name'] = '西西'
print(xixi['name'])

del xixi['name']
print(xixi['name'])

常用内置函数 当作函数调用

class Person:
    #对象当作函数调用，会自动触发
    def __call__(self, *args, **kwargs):
        # print('__call__')
        return sum(args)
xixi = Person()
print(xixi(1,2,3))


def text():
    pass

# 判断一个对象是否可以调用
print(callable(xixi))
print(callable(text()))

# 判断一个对象是否拥有__call__属性
print(hasattr(xixi,'__call__'))
print(hasattr(text(),'__call__'))

# 判断是否是函数
from inspect import isfunction
print(isfunction(text))
print(isfunction(xixi))

面向对象的特点

封装：即是对数据的封装，又是对数据方法的封装

继承：强调的是父子类的关系

多态：不同对象调用相同的方法，有不同的响应

继承属性重写

super().eat() 父类属性重写

多继承

继承链的查找顺序 __mro__属性记录了继承链的查找顺序，一旦找到立刻停止查找并返回，使用广度遍历的方式查找
for i in Son