Python学习笔记
开发
python中的基本数据类型有：布尔值、数字、字符串、元祖、字典。
开发语言
高级语言：Python、Java 、PHP、C#、GO、ruby、C++……
低级语言：C语言、汇编
语言之间的对比
PHP类：适用于写网页，局限性
Python Java:即可写网页，也可以写后台程序
Pyhont执行效率低，开发效率高
Java执行效率高，开发效率低
Python种类
JPython
IRonPython
JavaScriptPython
RubyPthon
……
pypy 这是用CPython开发大的Python
安装：
Python安装在OS上
执行操作：
洗衣歌文件中按照python的规则写，将文件交给python软件，读取文件中都内容，然后进行换行 和执行，最终获取结果。
Python软件 --> Python解释器（内存管理）
下载：
Python3 在继续更新
Python2 再继续更新
基本数据类型
关键字解释
常用方法中出现的参数名解释:
数据类型：
bool：布尔类
int：整数类
list：列表类
tuple：组员类
dict：字典类
自定义表格参数名称说明：
ele：列表元素
var：变量，各种数据类型的变量
int1：整数对象1
int2：整数对象2
ch1：字符1
ch2：字符2
str1：字符串对象1
str2：字符串对象3
list1：列表对象1
list2：列表对象2
tuple1：组员对象1
tuple2：组员对象2
dict1：字典对象1
dict2：字典对象2
key1：字典键名1
key2：字典键名2
方法、函数原型内参说明：
value：值
index：索引值
iterable：可迭代对象
bool 类
bool类说明
ls = [12, 4.5, "fjdk", [4, "fd"], True] list类是一种类，而ls属于list对象。
常用方法中出现的参数名解释
bool对象可调用方法
| 方法原型 | 使用举例 | 参数说明 |
|---|---|---|
| def append(self, p_object) | list.append(p_object) | 在原来列表list后进行追加元素p_object |
int 类
int()：
int：整形
在python3里面所有的整形都是int类型
int对象可调用方法
| 方法原型 | 简介 | 使用举例 | 参数说明 |
|---|---|---|---|
| def int(tar) | 转换为整形 | value = int(tar) | 将tar数据类型转换为int类型并返回给value |
| def int(tar， base = num) | 进制转换 | value = int(tar, base = 10) | 将tar数据类型转换以十进制格式转化为int类型并返回给value |
| def bit_lenth(self) | 数据占位长 | value = int.append() | 返回int当前值至少需要多少个bit为表示 |
扩展函数：type(var)；函数说明：判断var的数据类型，并以字符串的形式放回var的数据类型。
str 类
str对象可调用方法
| 方法原型 | 简介 | 使用举例 | 参数说明 |
|---|---|---|---|
| def capitalize(self) | 首字母大写 | str2 = str1.capitalize() | 将原字符串首字母大写然后进行返回 |
| def lower(self) | 转换小写 | str2 =str1.lower() | 将字符str1中的内容以小写的形式返回给str2 |
| def casefold() | 转换小写 | str2 =str1.lower() | 将str1转换为小写，包括一些特殊字符 |
| def center(self, widh, fillchar=None) | 设置宽度居中 | str1.center(widh) | 将字符str1以with的宽度显示，其中str1进行居中，边框默认应用空格填充 |
| def ljust(self, width, fillchar=None) | 设置宽度居左 | str1.ljust(widh) | 将字符str1以with的宽度显示，其中str1进行居左，右边默认应用空格填充 |
| def rjust(self, width, fillchar=None) | 设置宽度居右 | str1.rjust(widh) | 将字符str1以with的宽度显示，其中str1进行居右，左边默认应用空格填充 |
| def zfill(self, width) | 设置宽度居右 | str1.rjust(widh) | 将字符str1以with的宽度显示，其中str1进行居右，左边默认应用0填充 |
| def count(self, sub, start=None, end=Node) | 统计 | value = str1.count(sub) | 统计str1中sub出现的次数 |
| def encode(self, encoding=‘utf-8’, errors=‘strict’) | 后面学习 | ||
| def decode(self, encoding=‘utf-8’, errors=‘strict’) | 后面学习 | ||
| def startswith(self, suffix, start=None, end=None) | 判断起始 | value = str1.endswith(str2) | 判断str1是否已str2开始，是为True否则为False |
| def endswith(self, suffix, start=None, end=None) | 判断结尾 | value = str1.endswith(str2) | 判断str1是否已str2结尾，是为True否则为False |
| def find(self, sub, start=None, end=None) | 寻找 | value = str1.find(sub) | 返回判断字符串str1中sub元素首次出现的下标位置， 没有返回-1 |
| def expandtabs(self, tabsize=8) | 格式化转义字符 | str1.expandtabs(tabsize) | 将原字符串str1以tabsize个字符为分割，遇到\t时以空格补齐tabsize-分割后字符串个数 |
| def format(*args, **kwargs) | 替换占位符 | str3 = str1.format(placeholder = str2) | 将str1中的占位符名为placeholder替换为字符串str，并将替换后的结果返回给str3 |
| def format_amp(self, mapping) | 做占位符 | str2 = str1.format_map(“0”:str3, “2”:str4, …) | 与format()使用相似 |
| def index(self, sub, start=None, end=None) | 查找 | value = str1.index(sub) | 返回判断字符串str1中sub元素首次出现的下标位置， 没有直接报错。很少使用 |
| def isalnum(self) | 数字字母判断 | vlaue = str1.isalnum() | 判断字符串str1是否为纯数字字母组成，包含其他字符返回False |
| def isalpha(self) | 是否是字母 | value = str1.sialpha() | 判断字符串str1是否为纯字母或汉字，包含其他字符返回False否则返回True |
| def isdecimal(self) | 判断是否是数字 | value = str1.isdecimal() | 判断字符串str1是否是数字，全部是数字返回True否则返回False |
| def isdigit(self) | 数字判断 | value = str1.isdigit() | 判断字符串str1是否是数字，全部是数字返回True否则返回False，isdigit()能够判断特殊数字如：① |
| def isidentifier(self) | 标识符 | value = str1.isidentifier() | 判断字符串str1中的内容是否符合变量命名规则，即标识符，满足返回True不满足返回False |
| def islowre(self) | 小写判断 | value = str1.islower() | 判断字符串str1所有字符是否是小写，是小写返回Turue，不是小写返回False |
| def lowre(self) | 小写准换 | str2 = str1.lower() | 将字符串str1中的所有字符转换为小写然后返回到str2 |
| def isupper(self) | 大写判断 | value = str1.isupper() | 判断字符串str1中所有字符是否是大写，是大写返回Turue，不是大写返回False |
| def upper(self) | 大写转换 | str2 = str1.upper() | 将字符串str1中的所有字符串转换为小写然后返回到str2 |
| def isnumeric(self) | 数字判断 | value = str1.isnumeric() | 判断字符串str1是否是数字，全部是数字返回True否则返回False ,isnumeric()能够判断特殊数字如：①、二 |
| def isprintable(self) | 是否存在不可显示字符 | value = str1.isprintable() | 判断字符串中是否包含不可见字符（\r、\n…）如果包含不可见字符返回False，不包含返回True |
| def isspace(self) | 是否是空格 | value = str1.isspace() | 判断字符串str1是否问纯空格，是空格返回True，不是空格返回False |
| def istitle(self) | 标题判断 | value = str1.istitle() | 判断str1是否是标题返回标题：是标题返回True，不是字符串返回False；标题：字符串中所有单词首字母大写 |
| def title(self) | 设置为标题 | str2 = str1.title() | 将str1中的字符串转换为标题的形式然后返回到str2 |
| def join(self, iterable) | 字符间隙填充 | str2 = ‘_’.join(str1) | 将字符串str1中的相邻字符串之间增加一个 '_'进行拼接，然后返回到str2 |
| def strip(self, chars=None) | 去除两边 | str2 = str1.strip() | 将str1中内容与chars相同子集删除，然后返回到str2 |
| def lstrip(self, chars=None) | 去除左边 | str2 = str1.lstrip() | 将str1中的内容左边去除chars指定字符，然后返回到str2；默认去除 空格、\n、\t |
| def rstrip(self, chars=None) | 去除右边 | str2 = str1.rstrip() | 将str1中的内容右边去除chars指定字符，然后返回到str2；默认去除 空格、\n、\t |
| def maketrans(self, *args, **kwargs) | 建立对应关系 | ele = str.maketrans(str1, str2) | 将字符串str1与str2对应字符建立对应关系 ，与方法translate()配合使用 |
| def translate(self, table) | 对应字符替换 | str2 = str1.translate(trans) | 将str1字符串中的内容按照trans的对应关系进行替换 |
| def partition(self, sep) | 字符串分割 | ele = str1.partition(ch) | 以第一字符ch进行将str1进行分割 |
| def lpartition(self, sep) | |||
| def rpartition(self, sep) | |||
| def split(self, sep, maxsplit) | 分割字符串 | ele = str1.split(sep) | 将字符串str1以 sep进行分割，而str1中的sep也同时删除 |
| def rplit(self, sep, maxsplit) | |||
| def splitlines(self, keepends=None) | 以空格分割 | ele = str1.splitlines() | 将字符串str1以空格为分割进行分割 |
| def swapcase(self) | 大小写转换 | str2 = str1.swapcase() | 将字符串str1的内容大写转换为小写，小写转换为大写然后返回到str2 |
| def resplace(self， old， new， count) | 字符串替换 | str2 = str1.replace(str3， str4) | 将字符串str1中包含与str3相等的字符串替换成str4，然后染回到str2 |
常用的6个基本字符串处理函数:
join、split、find、strip、upper、lower、replace
字符串格式化
字符串个格式化主要应用形式有：% 和 format()
str1 = “i am %s my hobby is alex” %“aaaa”
字符串的格式化用 %
当传入个多格式化数值的时候用:%()
格式化传入的符号有：%s、%d、%f、%()、%[]
%s可以传入任何数据
%d传入的数据为整数
%f 传入的数据为浮点数，与C个数格式化输入相似
%() 传入字典键名
字符串格式化应用示例
msg1 = 'i am %s my hobby is %s' %(str1 , str2) #拼接多个字符串
msg2 = 'i am %s my hobby is %3' %(str1 , str2) #拼接字符串和整数
msg3 = "float = %f" % float1 #格式化浮点数
msg4 = 'i am %(name)s age %(age)d' % {"name":"alex", "age":18} #传入字典
list 列表
list
1.列表的格式
2.列表可以嵌套任何数据类型
3.列表的索引和修改可以通过下标、分割方式
4.可以通过for、while进行逐一访问
5.可以通过切片的方式进行索引和修改
6.列表的删除del
7. in操作，列表元素索引通过 逗号（，）进行分割
8. 字符串转换成列表
9. 列表转换为字符串
10.当列表中只包含字符的时候可以使用：st = “”.join(ls)。如果列表中既有字符串又有数字是需使用for循环。
列表内可是字符、字符串、数字、bool等数据类型，链表内部还可以嵌套链表
列表的索引可以通过列表下标索引，索引下标从0开始
ls = [15, 126.5, 'd', "hello", [12, 45, "fdfa"], False] #创建列表
print(ls[0]) #索引ls列表的第0个元素
print(ls) #输出ls列表所有元素
ls[4] = "Hello world" #通过下标索引方式进行修改
ls[1:3] = [100.5, 'c'] #通过切片方式进行修改
del ls[1:3] #通过切片的方式进行对列表元素的删除
print(15 in ls) #通过in进行判断15是否存在列表ls当中
s = "Hello"
new_ls = list(s) #将字符串s转换为列表list 类
list类说明
ls = [12, 4.5, "fjdk", [4, "fd"], True]list类是一种类，而ls属于list对象。
list类可调用的方法
| 方法原型 | 简述 | 使用举例 | 参数说明 |
|---|---|---|---|
| def append(self, p_object) | 追加元素 | list.append(p_object) | 在原来列表list后进行追加元素p_object |
| def clear(self) | 清空列表 | list.clear() | 清空列表list |
| def copy(self) | 拷贝 | list_new = list.copy() | 拷贝，浅拷贝 |
| def count(self, value) | 统计相同元素 | int = list.count(value) | 返回list列表中与value元素相同的个数 |
| def extend(self, iterable) | 追加元素 | list.extend(new_list) | 将new_list扩展到list后面，iterable参数为可迭代对象 |
| def index(self, value, start=None, stop=None) | 搜索元素 | num = list.index(value) | 返回列表list中元素value首次出现的下标 ，从左到右查询 |
| def insert(self, index, p_object) | 插入元素 | list.insert(index, p_object) | index：插入元素下标， p_object：要插入的元素。在制定位置插入元素 |
| def pop(self, index=None) | 移除元素 | ele = list.pop() | 默认删除列表list最后的元素，并将删除元素返回到ele， index：删除索引元素 |
| def remove(self, value) | 移除元素 | list.remove(value) | 删除列表中的第一次出现于value值相同的元素 |
| def reverse(self) | 列表反制 | list.reverse() | 将当前列表list进行翻转操作 |
| def sort(self, key=None, reverse=False) | 列表排序 | list.sort() | 对原列表list进行排序，默认为升序 |
删除列表元素的方式有：
del list[index]、list.pop()、list.remove(value)、list.clear()
tuple 元组
列表：li = [1, 2, 3, 4]，列表对应的对象是list
元组：tu = (1, 2, 3, 4)，元组对应的对象是tuple
列表与元组从定义上就是方括号变成圆括号的区别，其实元组就是对列表的一个二次加工，他把列表加工成了元素不能被修改，并且不能删除，能查看。
一般在写元组的时候在右边圆括号前面添加一个逗号(,)。
元组可以被for循环，元组也是可迭代对象。
字符串、列表、元组之间可以相互转换。
总结：
- 元组书写格式用圆括号
- 可以用索引的方式访问
- 元组创建后，一级元素不能被删除/修改 /增加
- 元组可以进行切片
- 元组是可迭代对象，也可以被for循环
- 可迭代对象之间可以进行转化
- 元组也是***有序***的
元组应用场合：
元组什么时候定义元组呢，当定义的数组以后不能更改的时候可以使用元组。
元组应用示例：
# 字符串、列表、元组之间的相互转换
#------------------------------------------------------------
str1 = "dghglk46652" #创建字符串对象str1
list1 = ["fda", 456, "fdfh"] #创建列别表对象list1
tuple1 = ("fdgfk", "jgnbn",) #创建元组对象tuple1
str2 = str(list1) #将列表准换为字符串
str3 = str(tuple1) #将元组转换为字符串
list2 = list(str1) #将字符串转换为列表
list3 = list(tuple1) #将元组转换为字符串
tuple2 = tuple(str1) #将字符串转换为元组
tuple3 = tuple(list1) #将列表转换为元组
# 元组的读取与修改
#------------------------------------------------------------
tuplt1 = (154, "aaa", ["bbbb", 15, ["ccc"], 1445],)
value1 = tuple1[0] #获取元组一级元素
value2 = tuple1[2][0] #获取元组二级元素
#tuple1[1] = "dfjk" X #语句错误，元组第一级元组不能被修改
tuple1[2][1] = 46 #修改元组的第二级元素 ，列表的元素能够被修改tuple类可调用的方法
| 方法原型 | 简述 | 使用举例 | 参数说明 |
|---|---|---|---|
| def count(self, value) | 统计value | value1 = tuple1.count(value) | 统计元组tuple1中value1出现的次数返回发到value |
| def index(self, value, start=None, end=None) | 获取位置 | value1 = tuple1.index(value) | 统计元组tuple1中value1首次出现的位置返回发到value |
dict 字典
创建一个字典： info = {“key1”:“value1”, “key2”:“value2”}
字典中以逗号进行分割，上面的列子创建了两个值，“d1”:"value1"的组合称为 键值对 ， 对应 键名:键值。
总结：
- 字典书写格式用花括号 {}。
- 字典的元素是一个键值对。
- 字典的元素以逗号进行分割。
- 字典的键不能使用列表/字典，字典的值可以是任何数据类型。
- 字典的键名不要重复，如果发生重复使用最后一次定义的键名。
- 字典是 无序 存放的。
- 字典的查询和修改通过键key进行索引。
- 元组也是有序的。
- 字典可以通过 del 进行删除元素。
- 字典允许通过for循环进行遍历
字典的应用示例
# 创建字典
#------------------------------------------------------------
info = {
1:"aaaaaa"
"key1":"bbbbb"
False:"cccccc" #用布尔值做为字典的key
# [11, 22]:1122 #字典的key不能使用列表
# {key1:44}:45 #字典的key不能使用字典
"key2":[45, 687, "dddd"] #
"key3":{True, 123, "elcx", [], (), {}}
"key4":(1, 2, 3, 4)
}
# 字典的访问和修改
#------------------------------------------------------------
value = info["key1"] #获取字典键为key1的元素数据
print(value)
value = info["key2"][0] #获取字典键为key2元素数据为列表第一个元素
print(key2)
# 字典的遍历
#------------------------------------------------------------
#用法1获取键名
for item in info： #输出字典的键名key
print(item)
#用法2获取键名
for item in info.keys()： #输出字典的键名key
print(item)
#用法获取键值
for item in info.values()： #输出字典的所有value
print(item)
#用法4获取键名和键值
for k, v in info.items(): #输出字典的key和value
print(k + ":" + v)dict类可调用的方法
| 方法原型 | 简述 | 使用举例 | 参数说明 |
|---|---|---|---|
| def clear(self) | 清空元素 | dict1.clear() | 清空字典ditc1 |
| def copy(self) | 拷贝 | dict2 = dict1.copy() | 将字典dict1中的内容拷贝到字典dict2， copy为浅拷贝 |
| def formkeys(**args, **kwargs) | 创建字典 | dict1 = dict.formkeys([12, “key1”, “key2”]) | **args为创建键名列表，默认创建键值默认为None |
| def get(self, k, d=None) | 读取键值 | value = dict1.get(key1) | 返回查询字典dict1的键名为key1的键值，如果键名不存在默认返回None |
| def keys(self) | 遍历键名 | for key in dict1.items(): | 遍历字典dict1的键名 |
| def values(self) | 遍历键值 | for value in dict1.items(): | 遍历字典dict1的键值 |
| def items(self) | 遍历元素 | for k, v in dict1.items(): | 遍历字典dict1的键名:键值 |
| def pop(self, k, d=None) | 删除元素 | value = dict1.pop(key1) | 寻找字典dict1中的键名并删除键名元素，将删除键名元素的键值返回给value |
| def popitem(self) | 删除元素 | k ,v = dict1.popitem() | 随机删除字典dict1中的一个元素，将返回删除元素的键名和键值分别返回到k和v，删除键值不存在默认返回None |
| def setdefault(self, k, d=None) | 设置元素 | key2 = ditc1.defaule(key1, value) | 如果字典dict1中的键值不存在返回将添加键值key1，字典dict1中存在该键名将返回键值 |
| def update(sef, E=None ,**F) | 更新 | dict1.update(key1:‘121’, key2:45) | 更新字典dict1，若字典存在键名则设置键值，如果字典中不存在键则创建键名并设置键值 |
集合
集合定义：有不同的元素组成的集合，集合中是一组无序排列的可hash值，可以可以作为字典的key
集合特性：
1.无序
2.不可变
集合的使用
#-----------------------------
# 创建集合
s1 = {1,2,3,4,5,6} #创建集合
s2 = set([1,2,3,4,5,6]) #创建集合
s2.add("jk") #向集合中添加元素
s1.clear() #清空集合
集合类可调用的方法
| 方法原型 | 简述 | 使用举例 | 参数说明 |
|---|---|---|---|
| def add(self, *args ,**kwargs) | 添加元素 | s1.add(“jk”) | 向集合1中添加元素 |
| def clear(self, *args, **kwargs) | 清空集合 | s1.clear() | 将集合s1中的元素清空 |
| def copy(self, *args, **kwargs) | 拷贝集合 | 上 = s1.copy() | 将集合s1复制到集合s2中 |
| def pop(self, *args, **kwargs) | 删除元素 | s1.pop() | 删除集合s1中的一个元素 |
| def remove(self, *args, **kwargs) | 删除元素 | s1.remove(get1) | 将集集合s1中的与get1值相等的元素删除，删除元素不存在报错 |
| def discaed(self, *args, **kwargs) | 删除元素 | s1.discaes(get1) | 与remove相似，删除元素不存在不报错 |
| def intersection(self, other) | 交集 | s3 = s1.intersection(s2) | 获取集合s1 |
| def union(self, other) | 并集 | s3 = s1.union(s2) | 求集合s1与集合s2的并集，把结果返回给s3；与s1 l s2结果相等 |
| def fifference(self, other) | 差集 | s3 = s1.difference(s2) | 返回集合s1减去集合s1与s2的交集，与s3 = s1-s2结果相同 |
| def symmetric_difference(self, other) | 交叉补集 | s3 = s1.symmetric_difference(s2) | 返回集合s1、s2的并集减去s1、s2的交集，把计算单额结果返回大s3，与s3 = s1^s2结果相同 |
| def difference_update(self, other) | 交叉补集 | s1.difference_update(s2) | 返回集合s1、s2的并集减去s1、s2的交集，把计算的结果直接更新到s1中，与s1 = s1^s2结果相同 |
| def isdisjoint(self, other) | 判断交集空 | value = s1.intersection(s2) | 判断集合s1与s2的交集是否为空，为空返回True，不为空返回False |
| def issubset(self, other) | 判断子集 | value s1.issubset(s2) | 判断集合s1是否为集合s2的子集，是子集返回True， 不是子集返回False |
| def isupperset(self, other) | 判断父集 | value s1.isupperset(s2) | 判断集合s1是否为集合s2的父，是父集返回True， 不是父集返回False |
不可变集合
frozenset()
frozenset函数创建的集合不能被修改、追加、删除。
s1 = frozenset([“fdkls”, 154])
函数
函数定义
1. 函数定义格式：
def function(value):
"Create a function..."
value *= 2
return value格式说明：
def：定义函数的关键字；
function：用户自定义函数名；
()：用户传入函数参数；
"Create a function..."：函数描述（可写可不写，建议使用添加函数描述，方便以后对知道函数作用）；
return：返回或传出数据；
2. 总结使用函数的好处：
- 提高代码的使用效率，代码重用；
- 保持一致性，易维护；
- 可扩展性好。
3. 函数与过程
函数就就是上面函数定义格式类型方式，而过程就是函数中 没有return 语句，过程也是函数的一种形式。在函数中只要遇到return语句函数接结束并返回，一个函数中可以有多个return语句。
4. 函数的返回值
过程的返回值为None，函数可以返回各种数据类型，在返回多种数据类型的时候以 元组tuple 的形式进行返回。
5. 函数的参数
- 形参 只有在被调用时才分配内存，在调用结束时，即可释放所分配的内存单元。因此，形参只在函数内部有效。函数调用借宿返回主调用函数后则不能再使用该形参变量；
- 实参 可以是常量、变量、表达式、函数等，无论实参是何种数据的变量，在进行函数调用时，他们必须有确定的值，以便吧这些值传递给形参。因此预先用赋值，输入等办法是形参获得确定值；
- 位置参数 必须一一对应，不可缺少参数也不可多参数；
- 关键字参数 无需一一对应，不可缺少参数也不可多；
- 位子参数和关键字参数混合使用时，位子参数必须在关键字参数左边；
- 默认参数 可以在用户使用的时候设置默认参数值；
- 可变长参数，*args 接收的是一个 列表 或 元组 ， **kwargs 是传入字典。
6. 局部变量和全局变量
- 全局变量 在程序开始是顶头定义的变量，全局变量可以被整个程序调用；
- 局部变量 是在一个函数中定义或一个表达式中定义的变量；
- global 在函数中调用外部的全局变量；
- 在python3变量名命名规则，全局变量全部用大写，局部变量用小写。
7. 函数的递归
函数的递归就是函数自己调用函数自己。
递归特性：
- 必须有一个明确的结束条件；
- 每次进入更深次递归时，问题规模比上一次递归都应有所减少；
- 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用时通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会建一层栈帧。由于栈的大小是有限的，所以递归调用次数过多会导致栈溢出）。
8.匿名函数
lambda
匿名函数定义格式：
lambda 形参:形参+表达式
9.函数式编程
编程的方法论：
面向过程
函数式编程
面向对象
函数式编程：函数式 = 编程语言定义的函数+数学意义的函数
在函数式编程中定义函数过程中不进行创建变量，不修改变量
高阶函数：
- 函数接收的参数是一个函数名。
- 返回值中包含函数。
应用示例：
NAMR = "xiaoming0000" #定义全局变量
def calc1(x, y, z): #定义函数calc1函数
return x+y+z # x、y、z就是形参
def calc2(x, y, z=0): #定义带默认参数calc2函数
return x+y+z
def calc3(x, *args): #定可变长参数类型函数
return x
def calc4(x, *args, **kwargs): #*args（列表）必须放在**kwargs（字典）右边
return x
def print_name():
global NAME
NAME = "xiaoming0001"
value1 = calc1(1, 2, 3) #使用位置参数调用函数
value2 = calc1(y=1, x=2, z=3) #使用关键字参数调用函数
value3 = calc2(1, 2) #使用默认参数调用带默认参数函数
func = lambda x:x*x #创建匿名函数
print(func(5)) #调用匿名函数内置函数
range()
range()函数返回的是一个可迭代对象，在使用的时候不会打印创建的对象，range()函数返回的可迭代对象，返回类型是一个列表。range()函数在于for循环配合使用的时候会创建列表。
#-----------------------------
# 用法1：默认从0开始创建，创建到指定数值
value1 = range(50) #默认从0开始创建49
print(value1)
for i in value1:
print(i)
#-------------------------------
# 用法2：从 起始 值创建到 终止 值
value2 = range(10, 50) #从10开始创建到49
for i in value2:
print(i)
#-------------------------------
# 用法3：从 起始 值创建到 终止 值没间隔 多少个数值进行创建
value3 = range(1, 20, 3) #增值：从1开始每间隔3个数值创建一个知道大于终止值为止， 3也成为步长
for i in value3:
print(i)
#-------------------------------
# 用法4：从 起始 值创建到 终止 值没间隔 多少个数值进行创建
value3 = range(20, 1, -3) #减值：从20开始每间隔3个数值创建一个知道大于终止值为止， -3也成为步长
for i in value3:
print(i)for
for循环9*9乘法表
for i in range(1, 10):
str1 = ""
for j in range(1, 10):
if j > i:
break;
str1 += str(j) + "*" + str(i) + "=" + str(i*j) + '\t'
print(str1)
map
map 函数第一个参数是处理的方法，第二参数是一个可迭代对象。
函数作用将可迭代对象中的每个元素按照第一个参数的处理方法进行返回。
map函数是对原可迭代对象进行处理，返回还是原可迭代对象。
应用示例：
def add_one(num): #用户自定义处理函数
return num+1
list1 = [1, 5, 48, 25]
map(lambda x:x+1, list1)
print(list(list1))
map(add_one, list1)
print(list(list1))filter
filter 函数第一个参数是处理的方法，第二参数是一个可迭代对象。
函数作用：将可迭代对象中的元素按照第一个参数的方法进行做相应的处理。
filter函数处理原可迭代对象，移除被筛选元素，返回处理后新的可迭代对象。
应用示例：
def del_starts(ls): #用户自定义处理函数
return ls.startswith("ls")
list1 = ["ls_1", "ls_2", "sl_3", "ls_4"]
print(list1)
print(list(filter(lambda x:x.startswith("ls"), list1)))
list1 = ["ls_1", "ls_2", "sl_3", "ls_4"]
print(list(filter(del_starts, list1)))
reduce
使用reduce函数需添加 from functools import reduce
reduce 函数第一个参数是处理的方法，第二参数是一个可迭代对象。
函数功能：将可迭代对象中的每个元素进行做运算，返回做运算的值。
应用示例：
from functools import reduce
list1 = [1, 4, 5, 50]
print(list1)
print(list(filter(lambda x,y:x*y, list1)
print(list(filter(lambda x,y:x*y, list1, 1)abs
abs为取绝对值函数
应用实例：
print(abs(1))
print(abs(-1))all
all 函数将元素中的每个元素与True进行与运算，如果所有元素为True为返回结果为True。
应用实例：
print(all([1, 2, '1'])) #返回 True
print(all([1, 2, None])) #返回 False
print(all([1, 2, False])) #返回 False
print(all([1, 2, []])) #返回 Falseany
any 函数与all相反
应用实例：
print(any([1, 2, '1'])) #返回 False
print(any([1, 2, None])) #返回 True
print(any([1, 2, False])) #返回 True
print(any([1, 2, []])) #返回 Truebin
bin 函数将十进制转换为二进制
应用实例：
print(bin(5)) #返回 101oct
oct 函数将十进制转换为八进制
应用实例：
print(oct(5)) #返回 5hex
hex 函数将十进制转换为十六进制
应用实例：
print(bin(5)) #返回 5bool
any 函数将参数做bool运算。
空、None、0的布尔值为False， 其余都为True
应用实例：
print(bool(0)) #返回 False
print(bool(None])) #返回 False
print(bool(False)) #返回 False
print(bool(1)) #返回 Truebytes
bytes 函数查看字符串编码
应用实例：
test = "你好"
print(bytes(test, encoding='utf-8')) #返回'你好'的字符编码
print(bytes(test, encoding='utf-8').decode('utf-8')) #对test进行解码
#print(bytes(test, encoding='ascii')) #ascii不能编码中文chr
bytes 函数查看字符串编码
应用实例：
print(chr(97)) #返回97所以应的ascii
print(chr(45)) #返回45所以应的asciidir
dir 函数查看某个对象下都有哪些方法
应用实例：
print(dir(all)) #返回97所以应的ascii
print(dir(str)) #返回45所以应的asciihelp
help 函数查看某个方法的用法
应用实例：
print(dir(all)) #返回97所以应的ascii
print(dir(str)) #返回45所以应的asciidivmod
dir 函数做除法和求余数
应用实例：
print(divmod(10, 3)) #(3, 1)eval
eval 将输入数据类型以字符串形式进行返回
应用实例：
#用法1 准换位字符串
#---------------------------------
list1 = [1, 5, 45, 'jkfdf']
print(eval(10, 3)) #(3, 1)
#用法2 将字符串中的表达式进行运算
#---------------------------------
calc = '45+45*2-(15-2)'
print(eval(calc)) #(3, 1)hash
hash 可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型。
hash值的作用
应用实例：
hash('sfdkjfkghn')zip
zip 又称为拉链。zip函数有两个参数，将一个参数与第二参数的对应元素进行组合。
应用实例：
print(list(zip([1, 5, 6], ['fd', 'fd', 'fd']))) #输出：[(1, 'fd'), (5, 'fd'), (6, 'fd')]max
max 求最大值
- max函数处理的是可迭代对象，相当于一个for循环取出每个元素进行比较，注意，不同数据类型之间不能进行比较
- 每个元素之间进行比较，是从每个元素的第一个位置一次比较，如果这一个位置分出大小，后面的都不需要比较了，直接得出这俩元素的大小。
应用实例：
list1 = [1, 5, 6, 3, 9]
print(max(list1)) #求列表中最大值
dict1 = {'key1':45, 'key2':21, 'key3':95, 'key4':12, }
print(mas(zip(dict1.values, dict1.keys))) #求字典中的最大值，并输出字典的键值和键名min
min 求最小值
不同数据类型不能进行比较
应用实例：
list1 = [1, 5, 6, 3, 9]
print(min(list1)) #求列表中最小值
dict1 = {'key1':45, 'key2':21, 'key3':95, 'key4':12, }
print(min(zip(dict1.values, dict1.keys))) #求字典中的最小值，并输出字典的键值和键名文件
打开文件
open
文件打开的方式有r、w、a
文件默认打卡的方式只读
#方法1：默认打开方式 只读
#---------------------------------------------
fd = open("test_file.txt", encoding='utf-8') #打开文件名为test_file.txt文件，打开编码格式为utf-8
#方法2：以只读方式打开
#---------------------------------------------
fd = open("test_file.txt", 'r', encoding='utf-8') #以只写的模式打开
#方法3：以只写方式打开
#---------------------------------------------
fd = open("test_file.txt", 'w', encoding='utf-8') #以只写的模式打开with as
打开文件后自动关闭文件
with open('a.txt', 'w') as fd: #创建文件
fd.wirte('hello\n') #写文件关闭文件
close
关闭以打开的文件
fd = open("test_file.txt", encoding='utf-8') #打开文件名为test_file.txt文件，打开编码格式为utf-8
fd.close() #关闭文件写文件
write
write 读文件内容
w：模式。文件不存在创建文件，若文件存在则清空文件文件。
fd = open("test_file.txt", 'w', encoding='utf-8') #打开文件名为test_file.txt文件，打开编码格式为utf-8
fd.write("helx") //向文件中写入内容不加换行
fd.write("helx\n") //向文件中写入内容加换行
fd.close() #关闭文件writeable
writeable 读文件内容
w：模式。文件不存在创建文件，若文件存在则清空文件文件。
#以只写方式打开
#-----------------------------------------------
fd = open("test_file.txt", 'w', encoding='utf-8') #打开文件名为test_file.txt文件，打开编码格式为utf-8
print(fd.writeable()) //输出True
fd.close() #关闭文件
#以只读方式打开
#-----------------------------------------------
fd = open("test_file.txt", encoding='utf-8') #打开文件名为test_file.txt文件，打开编码格式为utf-8
print(fd.writeable()) //输出False
fd.close() #关闭文件writelines
writelines 写文件
以整行的方式向文件写数据
#以只写方式打开
#-----------------------------------------------
fd = open("test_file.txt", 'w', encoding='utf-8') #打开文件名为test_file.txt文件，打开编码格式为utf-8
fd.writelines("fdagagga") //向文件中写入一行数据
fd.close() #关闭文件
+ 模式
r+：文件可读可写，写入文件的时候以追加的方式。写的时候以光标的位置开始写。
w+：
x+：
a+：
追加
a模式：本省就是写模式。若文件存在则则在文件的后面进行追加。
#以只写方式打开
#-----------------------------------------------
fd = open("test_file.txt", 'a', encoding='utf-8') #打开文件名为test_file.txt文件，打开编码格式为utf-8
fd.writelines("fdagagga") //向文件后添加数据
fd.close() #关闭文件
读文件
read()
读文件
fd = open("test_file.txt", encoding='utf-8') #打开文件名为test_file.txt文件，打开编码格式为utf-8
fd.close() #关闭文件readable()
判断文件是否以可读方式打开
#以只读的方式打开
#-----------------------------------------------------
fd = open("test_file.txt", encoding='utf-8') #以默认只读方式打开
print(fdreadable()) #输出True
fd.close() #关闭文件
#以只写的方式打开
#-----------------------------------------------------
fd = open("test_file.txt", 'w', encoding='utf-8') #以只写方式打开
print(fdreadable()) #输出False
fd.close() #关闭文件readlines()
从文件中一行一行的读
fd = open("test_file.txt", encoding='utf-8') #打开文件名为test_file.txt文件，打开编码格式为utf-8
print(fd.readlines()) #输出从文件中读取一行的内容
fd.close() #关闭文件home
2586
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
