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() 方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略。

字典，字符串，列表

字符串基础知识

字符串不能修改，列表可以

1. 字符串的定义
2. 判断某个元素是否在该字符串中
3. 字符串拼接
4. 内置方法

# 字符串
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)