Python基础知识
一些Python内置函数
filter()函数：
filter(function, iterable)过滤掉不符合条件的元素，返回由符合条件的元素组成的新列表。
def is_odd(n):
return n % 2 == 1 newlist
= filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)
1，3，5，7，9
map()函数：
map(function, iterable, …)会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
>>>def square(x) : # 计算平方数
... return x ** 2
...
>>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方
[1, 4, 9, 16, 25]
np.prod() 函数：
zip() 函数
>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
enumerate() 函数
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
... print i, element
...
0 one
1 two
2 three
MiniImagenet
这个为公开的数据集，当用我们的数据集的时候，我们是否可以选用里面的函数的形式？？Pycharm找到这个函数，Ctrl点进去，有compose和normalize等一些列函数。
strip()函数
声明：s为字符串，rm为要删除的字符序列
s.strip(rm) 删除s字符串中开头、结尾处，位于 rm删除序列的字符
s.lstrip(rm) 删除s字符串中开头处，位于 rm删除序列的字符
s.rstrip(rm) 删除s字符串中结尾处，位于 rm删除序列的字符
（1）当rm为空时，默认删除空白符（包括’\n’, ‘\r’, ‘\t’, ’ ')
（2）这里的rm删除序列是只要边（开头或结尾）上的字符在删除序列内，就删除掉。
split()函数
Python split() 通过指定分隔符对字符串进行切片
>>> str = ('www.google.com')
>>> print str
www.google.com
>>> str_split = str.split('.')
>>> print str_split
['www', 'google', 'com']
#split分隔后是一个列表，[0]表示取其第一个元素；
```python
>>> str_split = str.split('.')[0]
>>> print str_split
www
>>> str_split = str.split('.')[::-1]
>>> print str_split
['com', 'google', 'www']
>>> str_split = str.split('.')[::]
>>> print str_split
['www', 'google', 'com']
sorted()，itemgetter方法
#怎么把字符串转换成数组
#sorted(iterable, key=None, reverse=False)
#iterable – 可迭代对象。
#key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
#reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
stri = input("接受逗号分隔的单词序列作为输入:").strip().split(",")
d = ','.join(sorted(stri,key=lambda x:x[0],reverse=False))
print(d)
#每次传入sorted的是每个list中的一个元素
#比如是list是['acs', 'bcs', 'mds', 'csd']，那么每次传入的是acs,bcs以此类推，所以比较x[0]
stri = input("接受逗号分隔的单词序列作为输入:").strip().split(",")
stri.sort()
#默认比较迭代元素的第一个元素的值，且该列表用逗号分隔，且按升序排列
print(','.join(stri))
infor = [('John', '20', '90'), ('Jonv', '17', '91'),
('Jonv', '17', '93'), ('Json', '21', '85'),
('Tom', '19', '80')]
## itemgetter方法
from operator import itemgetter
print(sorted(infor,key=itemgetter(0,1),reverse=False))
#如果传入的是字典的话
d1 = [{'name':'alice', 'score':38}, {'name':'bob', 'score':18}, {'name':'darl', 'score':28}, {'name':'christ', 'score':28}]
l = sorted(d1, key=lambda x:(x['score'], x['name']))
print(l)
## 用回车结束input的输入
```python
lines = []
while True:
s = input()
if s:
lines.append(s.upper())
else:
break
for sentence in lines:
print(sentence)
指定input的输入次数，且以列表形式存储
for _ in range(1,6):
inf = input("输入个人的信息(名称，年龄，高度):").split(",")
allinfor.append(tuple(inf))
set()函数
x=list(set(input("请输入").strip().split(" ")))
x.sort()
x
#set函数去重并排序，去重完是set类型，但是要及时用list将其改回。
ord()函数
ord('a')<ord(i)<ord('z') or ord('A')<ord(i)<ord("Z"):
使用ascii码来分辨字母与数字,ord（）就是用将（）里的数据转换成ascill码形式
正则表达式
compile() 函数
https://www.runoob.com/regexp/regexp-syntax.html
正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。
update() 方法
update() 方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。
字典，字符串，列表
字符串基础知识
字符串不能修改，列表可以
- 字符串的定义
- 判断某个元素是否在该字符串中
- 字符串拼接
- 内置方法
# 字符串
str1 = '1'
str2 = "2" # Python中单引号与双引号没什么区别
print(str1)
print(str2)
print(str2*200)
str3 = 'asdqwezxc'
print(str3[2:])
print('as' in str3) # 判断此字段是否在字符串之中
print('aq' in str3)
print(str1+str2) # 字符串拼接（效率很低）
eg1 = '......'.join([str1,str2]) # 通过单引号的符号连接将要拼接的两个字符串
print(eg1)
print("##########")
# 字符串内置方法
str4 = 'it is a bea\tutiful city 是 {name}\n'
print(str4.count('s')) # 统计数目
print(str4.capitalize()) # 字符串首字母大写
print(str4.center(100,'-')) # 居中（距离和符号）
print(str4.endswith('ful')) # 以某个内容结尾
print(str4.startswith('it')) # 以某个内容开始
print(str4.expandtabs(tabsize=20)) # 对\t的空格数改为20，默认为4
print(str4.find('b')) # 查找到的第一个元素，返回下标号
print("##########")
# 格式化输出
print(str4.format(name = 'beijing')) # 将name改为具体的名字
print(str4.format_map({'name':'shanghai'}))
print(str4.index('b')) # 查找索引值，和fund()相似，但是index找不到会报错
print(str4.isalnum()) # 不常用，是否是数字，字母，中文
print(str4.isdecimal()) # 不常用，是否是十进制的数
print(str4.isdigit()) # 是否为数字
print(str4.isnumeric()) # 是否为数字
print(str4.isidentifier()) # 是否为非法变量
print("##########")
print(str4.islower()) # 是否都是小写
print(str4.isupper()) # 是否都是大写
print(str4.isspace()) # 是否是个空格
print(str4.istitle()) # 每一个词的首字母是否是大写
print(str4.lower()) # 大写全部变小写
print(str4.upper()) # 小写全部变大写
print(str4.swapcase()) # 字母大小写反转
print(str4.ljust(100,':')) # 向左对齐
print(str4.rjust(100,':')) # 向右对齐
print("##########")
print(str4.strip()) # 去掉换行符，空格
print(123) # 前面的换行符被去掉
print("##########")
print(str4.replace('city','城市')) # 替换内容，也可以部分替换
print(str4.rfind('t')) # 真实的索引位置
print(str4.split(' ')) # 字符串的分割
print(str4.rsplit('b',1)) # 以右为准，以目标分割，分割一次
列表基础知识
列表可以修改
- 定义列表
- 增删改查，两个列表的合并，清空列表，将列表倒排，定位列表中某个元素的位置，如何定位复杂元素的位置,排序
# 列表基础
list_1 = ['a','b','c','d','e','f']
list_2 = ['apple','banana','watermelon','strawberry','banana','apple']
print(list_1)
print("##########")
# 列表得下标是从0开始的，之后的一次+1
print(list_1[0])
print("##########")
print(list_1[4])
print("##########")
print(list_1[1:3]) # 从下标为1的元素开始，到下标为3的终止
print("##########")
print(list_1[1:-2]) # -2是指将列表的顺序倒置，结尾变为开头，下标相对来说变为0向前依次 -1
print("##########")
print(list_1[::2]) # 前面两个冒号分别使用默认的参数，最后一个数字表示步长，两步一取
print("##########")
# 列表的增、删、改
list_1.append('z') # 在结尾加一个元素
print(list_1)
print("##########")
list_1.insert(1,'y') # 在指定位置增加元素，在a后b前插入y
print(list_1)
print("##########")
a = list_2.extend(list_1) # 将list_1和list_2合并
print(a)
print("##########")
list_1[4] = 'o' # 修改第五个元素
print(list_1)
print("##########")
list_1[2:3] = ['p','q'] # 修改连续的元素
print(list_1)
print("##########")
list_1.remove(list_1[3]) # 删除下标为3的元素
print(list_1)
print("##########")
list_1.pop(2) # 直接加下标
print(list_1)
print("##########")
# del list_1[2] 删除列表中的下标为2的元素
# del list_1 直接删除掉列表
# 列表的一些方法
# count
print(list_2.count('apple')) # count是计算出现次数的方法
print("##########")
# index
print(list_2.index('banana')) # 寻找banana在哪个位置
print("##########")
one_apple = list_2.index('apple')
print(one_apple)
list_3 = list_2[one_apple+1:]
two_apple = list_3.index('apple')
list_4_index = one_apple + two_apple +1
print(list_4_index) # 输出第二个位置
print("##########")
'''
你想找到其中是 ('b', XX, XX) 这样的元素，其中 XX 可以为任意值。这种情况无法通过 index 函数来获得，我们可以利用 sort 的 key 参数来实现。
list.sort（或者 sorted 函数）有一个 key 参数，你可以提供一个函数来作为排序的依据。此时我们可以传入以下值：
'''
'''随后我们会发现，所有形如 ('b', XX, XX) 的元素全部浮动到了列表的头部，此时我们访问 temp[0] 就可以获得想要查找的值了。
'''
temp = [('a', 1, 1.5),
('b', 2, 5.1),
('c', 9, 4.3)]
temp.sort(key = lambda x:x[0]!='b')
# reverse
list_1.reverse() # 倒叙
print(list_1)
print("##########")
# sort
list_5 = [6,4,3,7,5,5,8,1]
list_5.sort() # 排序（从小到大）
print(list_5)
print("##########")
# clear
list_5.clear() # 清空列表
print(list_5)
print("##########")
元组基础知识
元组不可修改
- 创建元组，创建一个元素的元组
- 元组的内部也可以是列表等形式？
>>> tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
>>> tu[1][2]["k2"].append("seven")
>>> print(tu[1][2]["k2"])
['age', 'name', 'seven']
>>>
#一个元素的元组必须在第一个元素后面加上逗号
tuple=(1,)
del tuple
#元组的访问
L = ('spam', 'Spam', 'SPAM!')
L[-2]=Spam
字典基础知识
字典是另一种可变容器模型，且可存储任意类型对象。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
- 创建字典，增删改查，更新字典，对字典根据关键字排序，根据值排序，
# 字 典
dictionary1 = {'country':'China','city':'beijing'} # 创建字典（常用），前面为键，后面为键值
dictionary2 = dict((('city','shanghai'),)) # 创建字典
# 键是不可变类型：整型，字符串，元组
# 可变类型有：列表，字典
print(dictionary1)
print(dictionary1['city'])
print(dictionary2)
# 字典两大特点：无序，键值唯一
print("##########")
dictionary2['city'] = 'tianjin' # 修改字典,增加内容，如果本次输入的内容在字典中没有则直接加上。
print(dictionary2)
print("##########")
return1 = dictionary2.setdefault('location','north') # 增加内容，如果有则不做修改
print(dictionary2)
print(return1) # 返回键值
print("##########")
print(dictionary1.keys()) # 查看字典当中用那些键
print(list(dictionary1.keys())) # 用列表的形式展示
print(dictionary1.values()) # 只查看键值
print(dictionary1.items()) # 将字典当中的所有键值对拿出
print("##########")
dictionary3 = {1:1,2:2}
dictionary4 = {1:3,4:5,6:7}
dictionary3.update(dictionary4) # 更新字典，如果有键相同，则更新键值；如完全没有，则更新在后方
print(dictionary3)
print(dictionary4)
print("##########")
# 删除字典
eg = dictionary3.popitem() # 不加键，则会随机删除键值对
print(eg,'||',dictionary3)
dictionary4.pop(6) # 删除键为6的信息
print(dictionary4)
del dictionary4[4] # 删除键为4的信息
print(dictionary4)
dictionary4.clear() # 清空字典，只留下框架轮廓
print(dictionary4)
print("##########")
dictionary5 = dict.fromkeys(['a','b','c'],['z','y']) # 分配率,将后面最为一个整体
print(dictionary5)
dictionary5['b'][0] = 'x' # 需要理解深浅拷贝
print(dictionary5)
print("##########")
print(sorted(dictionary5)) # 字典的排序
print(sorted(dictionary5.values())) # 根据值排序
print("##########")
# 字典的遍历
dictionary6 = {'num1':10,'num2':52,'num3':33}
# 效率较高
for i in dictionary6:
print(i,dictionary6[i])
print("##########")
# 效率很低
for a,b in dictionary6.items():
print(a,b)
print("##########")
#键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：
dict = {['Name']: 'Zara', 'Age': 7}
print "dict['Name']: ", dict['Name']
会爆错
#字典可以无限极嵌套
cities={
'北京':{
'朝阳':['国贸','CBD','天阶','我爱我家','链接地产'],
'海淀':['圆明园','苏州街','中关村','北京大学'],
'昌平':['沙河','南口','小汤山',],
'怀柔':['桃花','梅花','大山'],
'密云':['密云A','密云B','密云C']
},
'河北':{
'石家庄':['石家庄A','石家庄B','石家庄C','石家庄D','石家庄E'],
'张家口':['张家口A','张家口B','张家口C'],
'承德':['承德A','承德B','承德C','承德D']
}
}
for i in cities['北京']:
print(i)
***#循环内容可以为二级索引***
for i in cities['北京']['海淀']:
print(i)
#列表里也可以为任意类型
cities={
'北京':{
'朝阳':[{'国贸':{1,2,3},'CBD':{1,2,3},'天阶':{1,2,3},'我爱我家':{1,2,3},'链接地产':{1,2,3}}],
},
'河北':{
'石家庄':['石家庄A','石家庄B','石家庄C','石家庄D','石家庄E'],
'张家口':['张家口A','张家口B','张家口C'],
'承德':['承德A','承德B','承德C','承德D']
}
}
for i in cities['北京']['朝阳']:
print(i)
#如何边输入边更新字典
字典，列表，元组，字符串之间的转换
1.字符串转换为字典
利用eval()方法，可以将字典格式的字符串转换为字典
#字符串
"{'name':'zhangsan','age':14,'gender':'girl'}"
#字典
{'name': 'zhangsan', 'age': 14, 'gender': 'girl'}
#虽然形式一样但是字符串比字典多引号
2.字符串转列表，元组
str_1 = "1235"
str_2 = 'zhangsan'
list_1=list(str_1)
tuple_1 = tuple(str_1)
3.列表转字符串
利用‘’.join()将列表中的内容拼接程一个字符串
list_1 = ['a', 'b', 'c']
str_1 = ''.join(list_1)
print(type(str_1))
print(str_1)
4.列表转字典
利用for in rang将两个列表转换为字典
#列表的定义方法，是字符的话方括号里面需要加上引号
#里面是数字只需要用方括号括起来
list_1 = ['a', 'b', 'c']
list_2 = [1, 2, 3]
#用什么要先创建什么
dict_1 = {}
for i in range(len(list_1)):
#字典的索引可以不是数字
dict_1[list_1[i]] = list_2[i]
print(type(dict_1))
print(dict_1)
5.元组转字符串
使用方法__str__
tuple_1 = (1, 2, 3)
str_1 = tuple_1.__str__()
print(type(str_1))
print(str_1)
6.元组转列表
用list()方法直接转换
tuple_1 = (1, 2, 3)
list_1 = list(tuple_1)
print(type(list_1))
print(list_1)
7.元组不能转字典
8.字典转字符串
list1=['a','b']
list2=[1,2,3]
dict1={}
for i in range(len(list1)):
dict1[list[i]]=list2[i]
json.dumps(dict1)
9.字典转列表
用list()
dict_1 = {"name":"zhangsan",
"age":18}
list_1 = list(dict_1)
print(type(list_1))
print(list_1)
集合
集合（set）是一个无序的不重复元素序列。
set方法对于列表，元组等类型既有重又有排序作用
有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：
为集合添加元素
移除集合中的所有元素
拷贝一个集合
返回多个集合的差集
移除集合中的元素，该元素在指定的集合也存在。
删除集合中指定的元素
返回集合的交集
判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
判断指定集合是否为该方法参数集合的子集。
判断该方法的参数集合是否为指定集合的子集
随机移除元素
移除指定元素
返回两个集合中不重复的元素集合。
移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
返回两个集合的并集
给集合添加元素
list = [9,8,1,1,2,3,4,5,3,1,4,6,5]
set(list)
#注意set方法传入的元素必须用括号括起来。set传入对象只能是一个。
>>> thisset = set(("Google", "Runoob", "Taobao"))
>#可以传入字符串
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
#可以传入列表
>>> thisset.update([1,4],[5,6])
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}
>>>
s.update( {"字符串"} ) 将字符串添加到集合中，有重复的会忽略。
s.update( "字符串" ) 将字符串拆分单个字符后，然后再一个个添加到集合中，有重复的会忽
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> print(thisset)
{'Google', 'Runoob', 'Taobao'}
>>> thisset.update({"Facebook"})
>>> print(thisset)
{'Google', 'Runoob', 'Taobao', 'Facebook'}
>>> thisset.update("Yahoo")
>>> print(thisset)
{'h', 'o', 'Facebook', 'Google', 'Y', 'Runoob', 'Taobao', 'a'}
>>>
迭代器生成器
字符串，列表或元组对象都可用于创建迭代器：
1.首先创建需要迭代的数据，如list=[1,2,3,4]
2.调用iter方法
3.用for方法循环输出元素
异常处理
try中的代码执行完后
def input_pwd():
# 1.提示用户输入密码
pwd = input("请输入密码：")
# 2.判断密码长度，如果长度 >= 6，返回用户输入的密码
if len(pwd) > 6:
return pwd
# 3.密码长度小于6位，则需要抛出异常
#此时的异常抛出相当于执行else，不满足if的条件时，就会抛出异常
# 创建异常对象
ex = Exception("密码长度小于6位")
# 抛出异常对象
raise ex
# 调用函数
try:
user_pwd = input_pwd()
print(user_pwd)
except Exception as e:
print(e)