一文带你了解python

简单介绍

1. python是脚本语言，不需要在使用变量前进行声明，代码不需要编译，由解释器来解释执行。
2. python简洁的语法可以让你写出比静态语言更短的程序。
3. 使用交互式解释器时，会自动打印输入的一些包含值的东西；在非交互式的程序中，需要使用print函数打印内容。
4. python中内置了一些自由体诗歌，在交互式解释器中输入import this可以看到。

基本元素

1. python基本元素有数字、字符串和变量，基本的内置数据类型有：

• 布尔型（True和False）
• 整型（整数）
• 浮点型（小数，或者科学计数法表示的数字）
• 字符串型（字符组成的序列）

2. python中的所有数据都是以对象的形式存在的，这就让python语言具有很强的统一性。python是强类型的，无法修改一个已有对象的类型。python中的变量仅仅是一个名字，赋值操作并不会实际赋值值，只是为数据对象取个相关的名字，名字是对对象的引用而不是对象本身。变量名只能包括大/小写字母，数字和下划线，并且变量名不能是保留关键字。

# 使用type(thing)语句可以获取变量或字面量的类型
>>> a=58
>>> type(a)
<class 'int'>

3. python本身支持整数以及浮点数，任何仅含有数字的序列在python中都会被认为是整数，一个数字序列定义了一个正整数，可以显示地在前面加上正好，不会使数字发生变化，可以加一个负号定义一个负数，加减乘除运算时运算符和数字之间的空格不是强制要求的。python右两种除法，/用来执行浮点除法，//用来执行整数除法。

>>> a = 95
>>> a -= 3
>>> a /= 3
>>> a //= 4
>>> 9 % 5
# divmod函数可以同时获得余数和商，返回一个元组
>>> divmod(9, 5)
(1, 4)

4. 操作符的优先级

描述符	描述
[v1, …]、{v1,…}、{k1:v1,…}、(…)	列表/集合/字典/生成器的创建和推导，括号内表达式
seq[n]、seq[n:m]、func(args…)、obj.attr	索引、切片、函数调用和属性引用
**	幂运算
+x、-x、~x	正号、负号和位取反
*、/、//、%	乘法、浮点除法、整数除法和取余
+、-	加法、减法
<<、>>	按位左移、按位右移
&	按位与
|	按位或
in、not in、is not、<、<=、>、>=、!=、==	属于关系和相当性测试
not x	布尔取非
and	布尔取与
or	布尔取或
if… else	条件表达式
lambda	lambda表达式

5. python中整数默认使用十进制数，除非显式指定使用其他基数。0b/0B表示二进制数，0o/0O表示八进制，0x/0X表示十六进制。比如0b10、0xa。
6. 我们可以使用int函数把其他数据类型转换成整型，保留数据的整数部分并舍去小数部分，可以接受浮点数或数字组成的字符串，但是无法接受包含小数点或指数的字符串。如果混合使用多种不同数字类型进行计算，python会自动进行类型转换。python2中一个int型包含32位，而python3中long类型已不存在，int类型可以存储任意大小的整数。

>>> int(True)
1
>>> int(98.9)
98
>>> int(1.0e4)
10000
>>> int('-23')
-23
# 抛出无效字面量异常
>>> int('98.6')
>>> 4 + 7.0
11.0
# 与证书或浮点数混合使用时，布尔型的False会被当做0或0.0，True会当做1或1.0
>>> True + 5.0
6.0
# 在其他语言中计算的数字或结果需要的存储空间超过了计算机提供的，
# 而python在处理超大数计算方面不会产生任何错误
>>> 10**100
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

7. 浮点数包含非数字的小数，运算符合整数相似。使用float函数可以将其他数字类型转换为浮点数。

>>> float(True)
1.0
# 整数转换为浮点数只需要添加一个小数点
>>> float(98)
98.0
>>> float('99')
99.0
# 将包含有效浮点数的字符串转换为浮点数
>>> float('1.0e4')
10000.0
>>> float('-1.5')
-1.5

8. 字符串是字符序列，python字符串是不可变的，可以将字符串的一部分复制到新字符串来达到修改的效果。将字符包裹在一对单引号或双引号中就可以创建字符串了。交互式解释器输出的字符串永远是单引号包裹的，两种引号的目的是可以创建本身就包含引号的字符串，而不用转义符。通过连续三个单引号或三个双引号也创建字符串，三元引号通常用于创建多行字符串，每行的换行符以及行首行末的空格都会被保留。

（1）使用str函数进行类型转换，调用print函数或者字符串差值时，python内部会自动使用str函数将非字符串对象转换为字符串。

>>> str(98.8)
'98.8'
>>> str(True)
'True'

（2）python允许对某些字符进行转义操作，比如\n表示换行符，\t表示制表符，\'表示单引号。使用+可以把多个字符串或字符串变量拼接起来，也可以将一个字符串字面量放到另一个的后面实现拼接。字符串拼接时，python不会自动添加空格，需要显示定义，但是当调用print函数打印时，会在各个参数之间自动添加空格并在结尾添加换行符。

>>> greeting = 'Hello\nWorld'
Hello
World
>>> 'How ' + 'old are you'
How old are you
>>> 'How ' 'old are you'
How old are you

（3）使用*可以进行字符串的复制，在字符串后面添加中括号[]并制定偏移量可以获取该位置的某个字符，第一个字符的偏移量是0，最后一个字符的偏移量也可以用-1表示。修改字符串可以使用replace函数等。

>>> start = 'Na ' * 4 + '\n'
>>> middle = 'Hey ' * 3 + '\n'
>>> end = 'Goodbye.'
>>> print(start + middle + end)
Na Na Na Na
Hey Hey Hey
Goodbye.
>>> letters = 'abcdefghijklmnopqrstuvwxyz'
>>> letters[0]
'a'
>>> letters[-1] 
'z'
>>> letters[5]
'f'
>>> letters[20:]
'uvwxyz'
>>> name = 'Poney'
>>> name.replace('P', 'H')
'Honey'
>>> 'H' + name[1:]
'Honey'

（4）分片操作可以从一个字符串中抽取子字符，起始偏移量start、终止偏移量end，步长step，分片得到的子串包括从start开始到end之前的全部字符。

• [:]提取整个字符串
• [start:]从start开始到结尾
• [:end]从开头到end-1
• [start:end]从start到end-1
• [start:end:step]从start到end-1，每step个字符提取一个

（5）使用len函数获得长度，计算字符串中包含的字符数。使用split函数可以基于分隔符将字符串分割成若干个子串组成的列表，如果不指定分割符号，默认使用空白字符（换行符/空格/制表符）。使用join函数将子串合成一个新的字符串。

>>> todos = 'get gloves,ge mask'
>>> todos.split(',')
['get gloves', 'get mask']
>>> str = ' '.join(['A', 'good', 'boy'])
>>> str
'A good boy'
# 字符串str以A开头
>>> str.startswith('A')
True
# 字符串str以boy结尾
>>> str.endswith('boy')
True
# 查找good在str中第一次出现的位置
>>> str.find('good')
2
# 查找good在str中最后一次出现的位置
>>> str.rfind('good')
2
# 查找good在str中出现了多少次
>>> str.count('good')
1

（6）使用strip函数可以删减字符串，capitalize函数将字符串首字母大写，title函数让所有单词的开头字母大写，upper函数让所有字母大写，lower函数让所有字母小写，swapcase函数让所有字母大小写转换，center函数设置居中，ljust函数设置左对齐，rjust函数设置右对齐。

>>> setup = 'a duck goes into a bar...'
# 把.都删掉
>>> setup.strip('.')
a duck goes into a bar
# 在第30个字符位居中
>>> setup.center(30)
'  a duck goes into a bar...   '
# 需要被替换的子串，用于替换的新子串，以及需要替换多少处，最多100
>>> setup.replace('a ', 'a famous ', 100)

容器

1. python容器有列表、元组、字典和集合。元组和列表是序列结构，都可以包括零个或多个元素，元组和列表不要求所含元素的种类相同，每个元素都可以是任何类型的对象。如此一来就可以创建具有任意深度及复杂度的数据结构。元组是不可变的，而列表是可变的。
2. 列表适合利用顺序和位置索引某一元素，可以添加、删除、修改已有元素，具有相同值的元素可以出现多次。

（1）使用[]或list()创建列表，list函数可以吧其他数据类型转换为列表类型。

>>> empty_list = []
>>> weekdays = ['Monday', 'Tuesday']
# 把一个字符串转换为由单个字母组成的列表
>>> list('cat')
['c', 'a', 't']
# 把一个元组转换成列表
>>> a_tuple = ('reday', 'fire')
>>> list(a_tuple)
['ready', 'fire']

（2）通过偏移量可以从列表中获取对应位置的元素，负偏移量表示从尾部开始计数，指定的偏移量对于待访问列表必须有效。对于包含列表的列表，可以使用多重索引获取元素。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> marxes[0]
'Groucho'
>>> marxes[-1]
'Harpo'
>>> marxes[2] = 'Wanda'
# 从列表的开头每2个提取一个元素
>>> marxes[::2]
['Groucho', 'Harpo']
# 列表逆序输出
>>> marxes[::-1]
['Harpo', 'Chico', 'Groucho']

（3）使用append函数添加元素到尾部，extend函数或者+=可以将一个列表合并到另一个列表中。insert函数可以将元素插入列表中的任意位置，指定偏移量为0可以插入列表头部，如果超过了尾部，则会插入列表最后。del函数删除指定位置的元素，位于后面的元素会自动往前移动填补空出来的位置并且列表长度减一,del是python语句，不是列表方法。remove函数删除具有指定值的元素。pop函数获取并删除指定位置的元素。

>>> marxes.append('Zeppo')
>>> others = ['Karl']
# 如果使用了apped，others会被当成一个单独的元素添加，而不是将内容合并
>>> marxes.extend(others)
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Zeppo', 'Karl']
>>> marxes.insert(3, 'Gummo')
>>> marxes
['Groucho', 'Chico', 'Harpo', 'Gummo', 'Zeppo', 'Karl']
>>> del maxres[-1]
>>> marxes.remove('Gummo')
# 没有指定偏移量，默认使用-1，返回列表的尾元素
>>> marxes.pop()
'Karl'
# 返回偏移量对应位置的元素
>>> marxes.pop(1)
'Chico'

（4）如果使用append函数添加元素到尾部，并通过pop函数从尾部删除元素，就可以实现后进先出的栈结构。如果使用pop(0)来删除元素就可以实现先进先出的队列结构。

（5）使用index函数可以查询具有特定值的元素位置。in可以判断值是否存在。count函数记录特定值出现的次数。join函数可以将列表转化为字符串。len函数可以获取列表的长度。

>>> marxes = ['Groucho', 'Chico', 'Harpo', 'Zeppo']
>>> marxes.index('Chico')
1
>>> 'Bob' in marxes
False
>>> marxes.count('Chico')
1
>>> ','.join(marxes)
'Groucho, Chico, Harpo, Zeppo'
>>> len(marxes)
4

（6）使用sort函数重新排列元素会改变列表内容，而使用sorted函数会返回排序好的列表副本但不改变列表内容。如果列表中元素都是数字，就默认是从小到大的升序；如果元素都是字符串，就会按照字母表顺序排列。当列表中元素有多种类型，只要它们之间能自动地互相转换也是可以排序的，通过添加参数reverse可以改变排序为升序或降序。

>>> marxes = ['Groucho', 'Chico', 'Harpo']
>>> sorted_marxes = sorted(marxes)
>>> sorted_marxes
['Chico', 'Groucho', 'Harpo']
>>> marxes
['Groucho', 'Chico', 'Harpo']
>>> marxes.sort()
>>> marxes
['Chico', 'Groucho', 'Harpo']
>>> numbers = [2, 1, 4.0, 3]
>>> numbers.sort(reverse=True)
[4.0, 3, 2, 1]

（6）如果把一个列表赋值给多个变量，改变其中的任何一处会造成其他变量对应的值也会被修改。通过列表的copy函数，list转换函数或者列表分片[:]都可以把一个列表的值复制到另一个新的列表中。

>>> a = [1, 2, 3]
>>> b = a
>>> a[0] = 'suprise'
>>> b
['surprices', 2, 3]
>>> a = [1, 2, 3]
>>> b = a.copy()
>>> c = list(a)
>>> d = a[:]
>>> a[0] = 'boring'
>>> a
['boring', 2, 3]
>>> b, c, d
([1, 2, 3, 3], [1, 2, 3, 3], [1, 2, 3, 3])

3. 元组和列表类似，元组被定义后无法进行增加、删除或者修改元素等操作。

（1）使用()创建元组，创建一个或多个元素的元组时，每个元素后面都需要跟着一个逗号。如果创建的元组包含的元素数量超过1，最后一个元素后面的逗号可以省略。定义元组真正靠的是每个元素的后缀逗号，如果习惯添加一对括号也可以。利用元组在一条语句中对多个变量的值进行交换，不需要借助临时变量。tuple函数可以将其他类型的数据转换为元组。

>>> empty_tuple = ()
>>> empty_tuple
()
>>> one_tuple = 'Happy',
('Happy',)
>>> marx_tuple = 'Mongo', 'Apple', 'Banana'
>>> marx_tuple
('Mongo', 'Apple', 'Banana')
# 元组解包是把元组赋值给多个变量
>>> a, b, c = marx_tuple
>>> a
'Mongo'
>>> c
'Banana'
>>> a, c = c, a
>>> a
'Banana'
>>> tuple(['Apple', 'Banana', 'Mongo'])
('Apple', 'Banana', 'Mongo')

（2）许多地方可以用元组替代列表，元组占用的空间较小，不会意外修改元组的值，可以将元组用作字典的键，命名元组可以作为对象的替代，函数的参数是以元组形式传递的。

4. 字典与列表类似，但是元素的顺序不重要，每个元素有互不相同的键，需要通过键访问元素。键通常是字符串，也可以是任意不可变类型。

（1）使用大括号{}将一系列以逗号隔开的键值对包裹起来就可以创建字典。python可以在列表、元组或字典最后一个元素后添加逗号，不会产生问题。dict函数可以将包含双值子序列的序列转换成字典。

>>> empty_dict = {}
>>> empty_dict
{}
>>> book_dict = {"Tom":"House", "Jerry":"Zoom"}
>>> book_dict
{'Tom': 'House', 'Jerry': 'Zoom'}
# 包含双值的列表
>>> lol = [['a', 'b'], ['c', 'd'], ['e', 'f']]
>>> dict(lol)
{'a': 'b', 'c': 'd', 'e': 'f'}
# 包含双字符的字符串组成的列表
>>> los = ['ab', 'cd', 'ef']
>>> dict(los)
{'a': 'b', 'c': 'd', 'e': 'f'}

（2）使用[key]添加或修改元素，向字典中追加元素只需要指定该元素的键并赋予相应的值就可以了，如果键已经存在，对应的旧值会被新值取代。字典的键必须保证互不相同。update函数可以将一个字典的键值对复制到另一个字典中。

>>> pythons = {'Cleese': 'John'}
>>> others = {'Marx': 'Groucho'}
>>> pythons.update(others)
>>> pythons
{'Cleese': 'John', 'Marx': 'Groucho'}
>>> pythons['Cleese']
'John'

（3）使用del删除具有指定键的元素。clear函数或者给字典变量重新赋值一个空字典可以删除所有元素。in语句可以判断一个键是否在一个字典中。

>>> del pythons['Marx']
>>> pythons
{'Cleese': 'John'}
>>> 'Cleese' in pythons
True
>>> pythons.clear()
>>> pythons = {}
# 如果键存在就返回键对应的值，如果键不存在就返回指定的可选值
>>> pythons.get('Cleese', 'Happy')

（4）通过[]获取元素，如果不存在键就会产生异常。避免异常的两种方法一是在访问前通过in判断键是否存在，另一种方法是使用get函数指定一个可选值。keys函数可以获取所有键的迭代形式。values函数可以获取字典中值的迭代形式。items函数获取所有键值对的迭代形式。

>>> signals = {'green':'go', 'yellow':'wait', 'red':'stop'}
>>> signals.keys()
dict_keys(['green', 'yellow', 'red'])
>>> list(signals.keys())
['green', 'yellow', 'red']
>>> list(signals.values())
['go', 'wait', 'stop']
>>> list(signals.items())
[('green', 'go'), ('yellow', 'wait'), ('red', 'stop')]

（5）与列表一样，对字典内容的修改会影响到所有与之相关联的变量名上，可以使用copy函数复制得到一个新字典后操作。

>>> signals = {'green':'go', 'yellow':'wait', 'red':'stop'}
>>> original_signals = signals.copy()
>>> signals['blue'] = 'confuse'
>>> signals
{'green': 'go', 'yellow': 'wait', 'red': 'stop', 'blue': 'confuse'}
>>> original_signals
{'green': 'go', 'yellow': 'wait', 'red': 'stop'}

5. 集合中的元素没有顺序，不允许重复。

（1）使用set函数创建集合，或者大括号将一系列以逗号隔开的值包裹起来。set函数还可以将其他类型转换为集合，其中重复的值会被丢弃。in语句可以测试元素是否在集合中。

>>> empty_set = set()
>>> empty_set
set()
>>> even_numbers = {0, 2, 4, 6, 8}
>>> event_numbers
{0, 2, 4, 6, 8}
# 把一个包含重复字母的字符串转换为集合
>>> set( 'letters' )
{'l', 'e', 'r', 't', 's'}
# 使用列表创建集合
>>> set(['Apple', 'Banana'])
{'Apple', 'Banana'}
# 使用字典作为参数传入set函数只有键会使用
>>> set({'apple':'red', 'orange':'orange'})
{'orange', 'apple'}

（2）如果查看多个集合间的组合的结果，可以使用集合运算符。集合的交集运算&结果是包含比较的两个集合中的所有元素的集合，还可以使用intersection获取交集。使用|或union函数可以获取集合的并集。使用-或difference函数可以获得差集。使用^或symmetric_difference函数可以获得异或集合。使用<=或issubset函数判断一个集合是否是另一个集合的子集。<可以判断是否是真子集。使用>=或issuperset函数判断一个集合是否是另一个集合的超集。

>>> drinks = {
...  'martini': {'vodka', 'vermouth'},
...  'black russian': {'vodka', 'kahlua'},
...  'manhattan': {'rye', 'vermouth', 'bitters'}
... }
# 含有vodka的drink
>>> for name, contents in drinks.items():
...   if 'vodka' in contents:
...     print(name)
...
martini
black russian
>>> for name, contents in drinks.items():
...   if contents & {'vermouth', 'orange juice'}:
...     print(name)
...
martini
manhattan
>>> a = {1, 2}
>>> b = {2, 3}
>>> a & b
{2}
>>> a.intersection(b)
{2}
>>> a | b
{1, 2, 3}
>>> a.union(b)
{1, 2, 3}
>>> a - b
{1}
>>> a.difference(b)
{1}
# 异或集合，仅在两个集合中出现一次
>>> a ^ b
{1, 3}
>>> a.symmetric_difference(b)
{1, 3}
>>> a