你可能不知道的Python基础知识

 

 

内置函数

1. dir(__builtins__)：查看三个方面的内容：异常名称、相关的属性名称（如__debug__）、内置函数的名称。
2. help(str.isalnum)：查看函数的具体使用方法。

常用内置函数

• isinstance() 判断类型的函数

hello = “rar”
isinstance(hello,str)

结果：True
 

• id(3) 查看数据的内存分配地址

• eval(“print(x)”) 将字符串转换成Python语句执行

• round(x) 四舍五入函数

• abs(x) 绝对值函数

• type(x) 查看类型函数

• filter(func,seq) 过滤函数，过滤掉使指定函数运行结果为假的元素

seq = [“foo”,”x86”,”?!”,”^&*”]
def func(x):
    return x.isalnum()
list(filter(func,seq))

结果是：[“foo”,”x86”]

• map()映射函数

list(map(str,range(5)))

结果是：[“0”,”1”,“2”,“3”,“4”]

• enumerate()枚举函数

list(enumerate(‘abcd’))

结果是：[(0,’a’),(1,’b’),(2,’c’),(3,’d’)]

list(enumerate([“Python”,”Greate”]))

结果是：[(0,“Python”),(1,”Greate”)]

• zip()拉链函数

list(zip(‘123’,‘abcd’,’?.!’))

结果是：[(‘1’,’a’,’?’),(‘2’,’b’,’.’),(‘3’,’c’,’!’)]

filter、map、enumerate、zip函数的特点：访问过的元素不可以再次访问。如：

x = map(str,range(5))
list(x)

结果是：[‘0’,’1’,’2’,’3’,’4’]

list(x)

结果是：[ ]

lambda 表达式：用来声明匿名函数

• 使用示例：

f = lambda x,y,z:x+y+z
f(1,2,3)

结果是：6

g = lambda x,y=2,z=3:x+y+z
g(1)

结果是：6

L = [(lambda x:x**2),(lambda x:x**3)]
print(L[0](2),L[1](2))

结果是：4 8

L = [1,2,3,4,5]
print(list(map(lambda x:x+10,L)))

结果是：[11,12,13,14,15]

list(map(lambda x:str(x),[1,2,3])) # lambda中调用函数

结果是：[‘1’,’2’,’3’]

• 利用lambda进行排序：

import random
data = list(range(15))
random.shuffle(data)
data.sort(key=lambda x:len(str(x)))
data

结果是：[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
 

data.sort(key=lambda x:len(str(x)),reverse=True)
data

结果是：[10,11,12,13,14,0,1,2,3,4,5,6,7,8,9]

序列

1. 字符串、列表、元组都是序列。

2. 使用列表推导式实现嵌套列表的平铺：

>>>vec = [[1,2,3],[4,5,6],[7,8,9]]

>>>[num for elem in vec for num in elem]

[1,2,3,4,5,6,7,8,9]

>>>[(x,y) for x in range(3) for y in range(3) if x !=y]

[(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)]

• list.extend(L) 将列表L的所有元素加至list列表尾部

• 包含一个元素的元组，最后必须多写个逗号，如(2,)。

• 元组的标志不是小括号，而是逗号。

• 元组与列表的区别：

• 元组不可以修改；

• 元组的速度比较快，如果只用来遍历，而不修改，则一般使用元组；

• 元组可以用作字典的键，也可以作为集合的元组，列表都不行。

序列解包

1. >>>x,y,z = 1,2,3
2. >>>a,b,c = ‘ABC’
3. 除切片的序列解包两侧元素个数可不相等外，其余情况下应对应。

>>>x = [1,2,3,4,5,6]

>>>x[:3] = map(str,range(5))

>>>x

[‘0’,’1’,’2’,’3’,’4’,4,5,6]

     4.序列解包遍历多个序列：

>>>keys = [‘a’,’b’,’c’,’d’]

>>>values = [1,2,3,4]

>>>for k,v in zip(keys,values):

   print((k,v),end=’’)

生成器推导式

1. 特点：
   1. 结果是一个生成器对象，可按需转变为列表或者元组；也可以使用该对象的__next__()方法或内置next()函数直接遍历；也可以直接作为迭代器对象使用。
   2. 有惰性求值的特点，即只在需要时生成新元素，效率更高。
   3. 只能访问一次。
2. 形式：(exp for e in sequence for exp in e if condition)
3. 例子：>>>g = ((i+2)*2 for i in range(10))

      >>>g.__next__()

  4

  >>>g.__next()

  6

  >>>next(g)

  8

字符串

• 字符串是不可修改的类型，只能重新创建。

• 字符串可以通过切片来访问。

• 字符串的替换：

>>>phone = '1386-666-0006'

>>>hiding = phone.replace(phone[:9],'*' * 9)

>>>print(hiding)

*********0006

• 字符串的复制：

>>>words = 'words' * 3

>>>print(words)

wordswordswords

• 字符串的格式化输出：

>>>age,h = 21,1.758

>>>print(“Age:{0:<5d},H:{1:5.2f}”.format(age,h))

Age:21   ,H: 1.76

>>>print('{} a word she can {}'.format('With', 'Win'))

>>>print('{p} can {v} '.format(p = 'He', v = 'Win'))

>>>print('{0} a word I can {1} '.format('With', 'Win'))

• dir(str)查看字符串处理的有关方法

• help(str.zfill)查看zfill()的使用说明

字典

• 创建字典的方式：

• 1.利用 = 和 { }

• 2.利用dict()，如：

c = dict([[‘Wang’,3000],[‘Niu’,4000],[‘Li’,5000]])

c = dict([(‘Wang’,3000),(‘Niu’,4000),(‘Li’,5000)])

c = dict(Wang=3000,Niu=4000],Li=5000)

• 3.利用dict.fromkeys() 创建，如：

>>>adict = dict.fromkeys([‘name’,’age’,’sex’])

>>>adict

{‘age’:None,‘name’:None,’sex’:None}

• 将两个列表对应成字典的方式

>>>names = [‘Wang’,’Niu’,’Li’]

>>>salaries = [3000,4000,5000]

>>>dict(zip(names,salaries))

{‘Wang’:3000,’Niu’:4000,’Li’:5000}

• 字典推导式

>>>x = [‘A’,’B’,’C’,’D’]

>>>y = [‘a’,’b’,’c’,’d’]

>>>{i:j for i,j in zip(x,y)}

{‘A’:’a’,’B’:’b’,’C’:’c’,’D’:’d’}

>>>{i:str(i) for i in range(1,5)}

{1:’1’,2:’2’,3:’3’,4:’4’}

• 字典的get()方法

dict.get(key, default=None)

key -- 字典中要查找的键。

default -- 如果指定键的值不存在时，返回该默认值。

>>>dict = {'Name': 'Zara', 'Age': 27}

>>>print "Value : %s" %  dict.get('Age')

>>>print "Value : %s" %  dict.get('Sex', "Never")

Value : 27

Value : Never

• 字典的update()方法：将另一字典的键值对添加到当前字典对象中。

>>>dict_a = {‘score’:[98,97],’name’:’Li’,’age’:38}

>>>dict_a.update({‘a’:’a’,’b’:’b’})

>>>dict_a

{‘a’:’a’,‘score’:[98,97],’name’:’Li’,’age’:38,’b’:’b’}

集合

• 集合是无序、不重复的元素集合，使用大括号界定。
• 集合中只能包含数字、字符串、元组等不可变类型，而不能包含列表、字典、集合等可变类型的数据。
• 集合中添加元素：

>>>a = {3,5}

>>>a.add(8)

>>>a

{3,5,8}

• 使用set()进行转换：

>>>a_set = set(range(8,13))

>>>a_set

{8,9,10,11,12}

>>>b_set = set([0,12,3,4,12,0,7])

>>>b_set

{0,3,4,7,12}

• 集合的删除：

1. del命令删除整个集合；
2. 集合的pop()方法随机弹出单个元素；
3. 集合的remove()方法删除指定元素；
4. 集合的clear()方法清空集合。

• 交集、并集、差集：

1. 并集：a_set | b_set 或a_set.union(b_set)
2. 并集：a_set & b_set或 a_set.intersection(b_set)
3. 差集：a_set - b_set或 a_set.difference(b_set)

（将b集合中与a集合相交的元素除去）

• 集合的包含关系：

>>>x < y （若为真，表示x是y的真子集）

True

>>>y >= x

• 集合的效率远远大于列表。

异常

try:

……

except ... as e:

……

except ... as err:

……

else:

……

finally:

……

（无论是否出现异常，finally子句中的语句都将执行。）