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)
13579

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() 函数:

Python基础知识_第1张图片

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等一些列函数。
Python基础知识_第2张图片

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)

你可能感兴趣的:(python)