[Python基础]一、基本数据类型：数字、字符串、列表、元组、字典与集合

需要导入random模块 import random。
random.choice(seq)：返回一个列表，元组或字符串的随机项。
random.randint(x,y)：随即返回一个整数，值域为[x,y]（左闭右闭）
random.sample(sequence,length)：从指定的序列中随机的截取指定长度的片断，不修改原序列。返回值为列表。
random.random()：返回随机生成的一个实数，它在[0,1)范围内。
random.shuffle (list)：将序列的所有元素随机排序。
random.uniform(x, y)：随机生成一个实数，它在 [x,y] 范围内。
random.seed ([x])：改变随机数生成器的种子，可以在调用其他随机模块函数之前调用此函数。
random.randrange ([start,] stop [,step])：返回指定递增基数集合中的一个随机数，基数默认值为1。

import random
lst = random.sample(set('abcd1234'),4) #原序列为列表，但仍然返回list类型
print(type(lst)) #<class 'list'>
strs = ''.join(lst) #将列表转化为字符串
print(strs) #2c13

# 从 1-100 中选取一个奇数
print ("randrange(1,100, 2) : ", random.randrange(1, 100, 2))
# 从 0-99 选取一个随机数
print ("randrange(100) : ", random.randrange(100))

数学函数

Python 3 已废弃cmp(x, y)，使用 (x>y)-(x<y) 替换。

不需要导入math模块
abs( x )：返回数字的绝对值。
pow(x, y[, z])：计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z。返回类型可以为整数。
round( x [, n] )：返回浮点数 x 的四舍六入值，n 表示保留的小数点位数。

需要导入math模块 import math。
math.sqrt( x )：返回数字x的平方根。
math.ceil( x )：返回一个大于或等于 x 的的最小整数。
math.floor( x )：返回数字的下舍整数，小于或等于 x。
math.exp( x ) ：返回以的指数， $e^x$ 。
math.fabs( x )：返回数字的绝对值
math.log( x )：返回x的自然对数，x>0。
math.log10( x )：返回以10为基数的x对数，x>0。
math.modf( x )：返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
math.pow( x, y )：返回 $x^y$ ，返回类型为浮点数。

数学常量

常量	调用
圆周率π	math.pi
自然常数e	math.e

二、字符串

使用引号( ' 或 " )来创建字符串。

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

#!/usr/bin/python3
var1 = 'Hello World!'
var2 = "Runoob"
#访问子字符串可以使用方括号来截取字符串
print ("var1[0]: ", var1[0])  #var1[0]:  H
print ("var2[1:5]: ", var2[1:5])    #var2[1:5]:  unoo
# 
#字符串更新：截取字符串的一部分并与其他字段拼接
print ("已更新字符串 : ", var1[:6] + 'Runoob!') #已更新字符串 :  Hello Runoob!

转义字符

\(在行尾时)续行符；\\反斜杠符号；；\'单引号；\"双引号；\a 响铃；\b 退格(Backspace)；\000 空；\n 换行；\v 纵向制表符；\t 横向制表符；\r 回车；\f 换页；\oyy 八进制数；\xyy 十六进制数。

Python字符串运算符

+ 字符串连接
* 重复输出字符串
[] 通过索引获取字符串中字符
[ : ] 截取字符串中的一部分，遵循左闭右开原则
in 成员运算符 - 如果字符串中包含给定的字符返回 True
not in 成员运算符 - 如果字符串中不包含给定的字符返回 True
% 格式字符串
r/R 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。print( r'\n' )输出\n

扫描二维码关注公众号，回复： 9088136 查看本文章

Python三引号

三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。
python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。
而单引号双引号引号内的回车换行，不是真正的换行，需要利用\n做到真正的换行。
适用场景在需要一块HTML或者SQL时。

Unicode 字符串

在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在Python3中，所有的字符串都是Unicode字符串。

Python 的字符串内建函数

bytes.decode(encoding="utf-8", errors="strict")：以指定的编码格式解码 bytes 对象然后返回。默认编码为 utf-8。
str.encode(encoding='UTF-8',errors='strict')：以指定的编码格式编码并返回格式字符串，返回的是一个 bytes 对象。

#!/usr/bin/python3
str = "菜鸟教程";
str_utf8 = str.encode("UTF-8")
str_gbk = str.encode("GBK")
print("UTF-8 编码：", str_utf8)  #UTF-8 编码： b'\xe8\x8f\x9c\xe9\xb8\x9f\xe6\x95\x99\xe7\xa8\x8b'
print("GBK 编码：", str_gbk)  #GBK 编码： b'\xb2\xcb\xc4\xf1\xbd\xcc\xb3\xcc'
print("UTF-8 解码：", str_utf8.decode('UTF-8','strict')) #UTF-8 解码： 菜鸟教程
print("GBK 解码：", str_gbk.decode('GBK','strict')) #GBK 解码： 菜鸟教程

len( s )：返回对象（字符、列表、元组等）长度或元素个数。
str.join(sequence)：将序列中的元素以指定的字符连接生成一个新的字符串。
str.split(str="", num=string.count(str))：通过指定分隔符对字符串进行切片，分割为 num+1 个子字符串。
str.replace(old, new[, max])：把字符串中的 old 替换成 new，如果指定第三个参数max，则替换不超过 max 次。
str.splitlines([keepends])：按照行(\r, \r\n, \n)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符

>>> 'ab c\n\nde fg\rkl\r\n'.splitlines()
['ab c', '', 'de fg', 'kl']
>>> 'ab c\n\nde fg\rkl\r\n'.splitlines(True)
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

str.strip([chars])：移除字符串头尾指定的字符（默认为空白符，包括/n, /r, /t, ' '）或字符序列。注意删除多个字符时：只要头尾有对应其中的某个字符即删除，不考虑顺序，直到遇到第一个不包含在其中的字符为止。
str.rstrip([chars])：删除 string 字符串末尾的指定字符
str.lstrip([chars])：删除 string 字符串头部的指定字符

str = '123132231213321312==321312213231123132'
print(str.strip('123')) #  ==

str.find(str, beg=0, end=len(string))：检测字符串中是否包含子字符串 str 。如果包含则返回起始的索引值，否则返回-1。
str.index(str, beg=0, end=len(string))：检测字符串中是否包含子字符串str ，如果str不在 string中会报一个异常。
str.center(width[, fillchar])：返回一个指定的宽度width 居中的字符串，fillchar 为填充的字符，默认为空格。
str.count(sub, start= 0,end=len(string))：统计字符串里某个字符出现的次数。
str.endswith(suffix[, start[, end]])：判断字符串是否以指定后缀结尾
max(str)：返回字符串中最大的字母。
min(str)：返回字符串中最小的字母。
str.isdigit()：检测字符串是否只由数字组成。
str.islower()：检测字符串是否由小写字母组成。
str.isupper()：检测字符串中所有的字母是否都为大写。
str.istitle()：检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
str.upper()：返回小写字母转为大写字母的字符串。
str.lower()：转换字符串中所有大写字符为小写。
str.title()：所有单词的首个字母转化为大写，其余字母均为小写。注意，非字母后的第一个字母将转换为大写字母。

txt = "hello bbb2b2 and 3g3g3g"
x = txt.title()
print(x) #Hello Bbb2B2 And 3G3G3G

str.partition(str)：从左向右遇到分隔符把字符串分割成两部分，返回头、分割符、尾三部分的三元组。如果没有找到分割符，就返回头、尾两个空元素的三元组。

s1 = "I'm a good sutdent."
print(s1.partition('good')) #("I'm a ", 'good', ' sutdent.')
print(s1.partition('abc')) #("I'm a good sutdent.", '', '')

三、列表

列表的切片

list[start:end:step]左闭右开
start：起始索引，从0开始，-1表示结束
end：结束索引，默认为列表长度。
step：步长，步长为正时，从左向右取值。步长为负时，反向取值

通过切片方式（list[:]）复制列表，结果是生成了两个列表。通过简单赋值方式（a=b）复制列表，两个列表是相同的。

#可以用 del 语句从列表中删除一个切割，或清空整个列表
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

Python列表脚本操作符

Python表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print(x, end=" ")	1 2 3	迭代

Python列表方法

list.append(obj)：在列表末尾添加新的对象。无返回值，但是会修改原来的列表。
list.count(obj)：统计并返回某个元素在列表中出现的次数。
list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值，seq可以是列表、元组、集合、字典，若为字典,则仅会将键(key)作为元素依次添加至原列表的末尾。
list.index(x[, start[, end]])：从列表中找出某个值第一个匹配项的索引位置。
list.insert(index, obj)：将指定对象插入列表的指定位置。
list.pop([index=-1])：移除列表中的一个元素（默认最后一个元素），并且返回从列表中移除的元素对象。
list.remove(obj)：移除列表中某个值的第一个匹配项。
list.reverse()：无返回值，对列表的元素进行反向排序。
list.sort( key=None, reverse=False)：没有返回值，会对列表的对象进行排序。reverse = False 升序（默认）。
list.clear()：清空列表，类似于 del a[:]，无返回值。
list.copy()：复制列表，类似于 a[:]，返回复制后的新列表。

#python 创建二维列表
list_2d = [[0 for col in range(cols)] for row in range(rows)]

列表推导式

[表达式 for 变量 in 列表]
[表达式 for 变量 in 列表 if 条件]

生成空列表

#创建一个占用十个元素空间的列表
>>> list_empty = [0]*10
>>> list_empty
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
#初始化长度为10但没有在里面放置任何元素的列表，可以使用None
>>> list_empty = [None]*10
>>> list_empty
[None, None, None, None, None, None, None, None, None, None]

删除两个列表中相同元素

a=[1,2,3]
b=[2,3,4]
diff=list(set(a).difference(set(b)))  #[1]

copy()浅拷贝

当原对象存在多层嵌套的情况下，浅拷贝copy()只拷贝了最外层的数据结构，最外层所包含的数据变化时，是不会相互影响的，但是当原数据对象内部嵌套数据中的数据发生变化后，相应的浅拷贝后的对象也会发生变化。

arr = [{'name': 'wcl', 'age': 23}, {'name': 'wjy', 'age': 14}]
arr2 = arr.copy()
del arr[1] #删除arr[]这个数组
arr[0]['age'] = 18
print('arr', arr) #arr [{'name': 'wcl', 'age': 18}]
print('arr2', arr2) #arr2 [{'name': 'wcl', 'age': 18}, {'name': 'wjy', 'age': 14}]

四、元组

元组的元素不能修改。
访问元组：使用下标索引来访问元组中的值。
修改元组：元素值不允许修改，但可以对元组进行连接组合
删除元组：元素值不允许删除，但可以使用del语句删除整个元组
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

注意：1.当定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来。
2.元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
3.函数返回多个值的时候，是以元组的方式返回的。

>>> tup = () #创建空元组

>>> tup = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>
>>> tup = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

tup3 = tup1 + tup2 #对元组进行连接组合

元组是不可变的

所谓元组的不可变指的是元组所指向的内存中的内容不可变。重新赋值的元组 tup，绑定到新的对象了，不是修改了原来的对象。

>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
>>> tup[0] = 'g'     # 不支持修改元素
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> id(tup)     # 查看内存地址
4440687904
>>> tup = (1,2,3)
>>> id(tup)
4441088800    # 内存地址不一样了

五、字典

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中。

字典键的特性

不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会覆盖前一个值。
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。

字典内置方法

key (not) in dict：判断键是否存在于字典中，如果键在字典 dict 里返回 (False)true
dict.clear()：删除字典内所有元素。没有返回值。
dict.copy()：返回一个字典的浅复制。
dict.fromkeys(seq[, value])：创建一个新字典，以seq中元素做字典的键，value为所有键对应的初始值，默认为None。
dict.get(key, default=None)：返回指定键的值，如果值不在字典中返回默认值。
dict.items()：以列表返回可遍历的(键, 值) 元组数组。
dict.keys()：返回一个可迭代对象，可以使用 list() 来转换为列表，列表为字典中的所有key。
dict.values()：返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有value。
dict.setdefault(key, default=None)：和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值。
dict.update(dict2)：把字典参数dict2的key/value对更新到dict里。如果键值有重复，则dict2的内容更新替换到dict中。
dict.pop(key[,default])：删除字典给定键 key 所对应的值，返回被删除的值。key值必须给出。否则，返回default值。
dict.popitem()：返回并删除字典中的最后一对键和值。

调换字典键与值

#注意原始value必须是不可变类型
reverse = {v: k for k, v in dic.items()}

字典推导式

{key:value for variable in iterable [if expression]}
执行步骤：

for 循环：遍历可迭代对象，将其值赋给变量。
if 语句：筛选满足 if 条件的结果。
存储结构：以键值对的方式存储在字典中

六、集合

集合（set）是一个无序的不重复元素序列。类似列表推导式，同样集合支持集合推导式(Set comprehension):

创建集合

parame = {value01,value02,...}或set(value)

创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

集合的基本操作

s.add( x )：将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
s.update( x )：添加元素，且参数可以是列表，元组，字典等。
s.remove( x )：将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
s.discard( x )：将元素 x 从集合 s 中移除，且如果元素不存在，不会发生错误。
s.pop() ：随机删除集合中的一个元素。
s.clear()：清空集合 s。
len(s)：计算集合 s 元素个数。
x in s：判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。

>>> # 两个集合间的运算.
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

集合的其余内置方法

set.copy()：拷贝一个集合，无返回值。
set.difference(set)：(a-b)返回集合的差集，即返回的集合元素包含在第一个集合中，但不包含在第二个集合(方法的参数)中。
set.difference_update(set)：(a-(a&b))直接在原来的集合中移除两个集合中都存在的元素，没有返回值。
set.symmetric_difference(set)：(a^b)返回两个集合组成的新集合，但会移除两个集合的重复元素
set.symmetric_difference_update(set)：``移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
set.intersection(set1, set2 ... etc)：(a&b)返回两个或更多集合中都包含的元素，即交集。
set.intersection_update(set1, set2 ... etc)：a&(a&b)在原始的集合上移除不重叠的元素。
set.isdisjoint(set)：判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
set.issubset(set)：判断集合的所有元素是否都包含在指定集合中，如果是则返回 True。
set.issuperset(set)：判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True
set.union(set1, set2...)：返回两个集合的并集

set() 中参数

#1.创建一个含有一个元素的集合
>>> my_set = set(('apple',))
>>> my_set
{'apple'}
#2.创建一个含有多个元素的集合
>>> my_set = set(('apple','pear','banana'))
>>> my_set
{'apple', 'banana', 'pear'}
#3.如无必要，不要写成如下形式
>>> my_set = set('apple')
>>> my_set
{'l', 'e', 'p', 'a'}
>>> my_set1 = set(('apple'))
>>> my_set1
{'l', 'e', 'p', 'a'}

set.update()

s.update( "str" ) 与 s.update( {"str"} ) 含义不同:

s.update( {"str"} ) 将字符串添加到集合中，有重复的会忽略。
s.update( "str" ) 将字符串拆分单个字符后，然后再一个个添加到集合中，有重复的会忽略。

>>> 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'}

>>> thisset = set(("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'}

七、进阶

遍历技巧

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
     print(i, v)

同时遍历两个或更多的序列，可以使用 zip() 组合：

>>> questions = ['name', 'quest']
>>> answers = ['lancelot', 'the holy grail']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))

要反向遍历一个序列，首先指定这个序列，然后调用reversed()函数：

>>> for i in reversed(range(1, 10, 2)):
...     print(i)

要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)

collections.defaultdict()

Python中通过Key访问字典，当Key不存在时，会引发KeyError异常。为了避免这种情况的发生，可以使用collections类中的defaultdict()方法来为字典提供默认值。
collections.defaultdict([default_factory[, …]])

该函数返回一个类似字典的对象。defaultdict是Python内建字典类（dict）的一个子类，它重写了方法_missing_(key)，增加了一个可写的实例变量default_factory,实例变量default_factory被missing()方法使用，如果该变量存在，则用以初始化构造器，如果没有，则为None。其它的功能和dict一样。

第一个参数为default_factory属性提供初始值，默认为None；其余参数包括关键字参数（keyword arguments）的用法，和dict构造器用法一样。

使用list作第一个参数，可以很容易将键-值对序列转换为列表字典。

from collections import defaultdict
s=[('yellow',1),('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
d=defaultdict(list)
for k, v in s:
    d[k].append(v)
print(d)
a=sorted(d.items())
print(a)

defaultdict(<class 'list'>, {'yellow': [1, 3], 'blue': [2, 4], 'red': [1]})
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

当字典中没有的键第一次出现时，default_factory自动为其返回一个空列表，list.append()会将值添加进新列表；再次遇到相同的键时，list.append()将其它值再添加进该列表。这种方法比使用dict.setdefault()更为便捷，dict.setdefault()也可以实现相同的功能。

s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
d={}
for k, v in s:
    d.setdefault(k,[]).append(v)
a=sorted(d.items())
print(a)

defaultdict还可以被用来计数，将default_factory设为int即可。

from collections import defaultdict
s = 'mississippi'
d = defaultdict(int)
for k in s:
    d[k] += 1
print(d)
a=sorted(d.items())
print(a)

defaultdict(<class 'int'>, {'m': 1, 'i': 4, 's': 4, 'p': 2})
[('i', 4), ('m', 1), ('p', 2), ('s', 4)]

字符串中的字母第一次出现时，字典中没有该字母，default_factory函数调用int()为其提供一个默认值0,加法操作将计算出每个字母出现的次数。
函数int()是常值函数的一种特例，总是返回0。使用匿名函数（lambda function）可以更快、更灵活的创建常值函数，返回包括0在内的任意常数值。

from collections import defaultdict
def constant_factory(value):
    return lambda: value
d = defaultdict(constant_factory('<missing>'))
print(d)
d.update(name='John', action='ran')
print(d)
print('%(name)s %(action)s to %(object)s' % d)

defaultdict(<function constant_factory.<locals>.<lambda> at 0x0000020AED33A048>, {})
defaultdict(<function constant_factory.<locals>.<lambda> at 0x0000020AED33A048>, {'name': 'John', 'action': 'ran'})
John ran to <missing>

default_factory设为set时，可以用defaultdict建立集合字典（a dictionary of sets）

from collections import defaultdict
s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]
d = defaultdict(set)
for k, v in s:
    d[k].add(v)
print(d)
a=sorted(d.items())
print(a)

defaultdict(<class 'set'>, {'red': {1, 3}, 'blue': {2, 4}})
[('blue', {2, 4}), ('red', {1, 3})]

magic_jiayu

发布了54 篇原创文章 · 获赞 3 · 访问量 3655

私信关注