python基础（一）

一、基本数据类型和运算符

注意：所有语法都是基于python3

1. 数据类型

（1）数值类型

• 整型：int，例如-5,5
• 浮点型：float，例如3.125
• 复数：complex，例如（-5+4j）

（2）字符串类型(str)

• 单引号/双引号：指定字符串
• 三引号：可以表示一个多行字符串
• 转义字符 \ ：在一行的末尾加 \，表示下一行的字符串是上一行的继续
• len() 函数返回字符串的长度
• strip() 方法删除开头和结尾的空白字符
• lower() 返回小写的字符串
• replace() 用另一段字符串来替换字符串
• 用 in 或 not in 关键字检查字符串中是否存在特定短语或字符
• 使用 + 运算符进行字符串联

使用format方法格式化字符串

"{} is a {}".format("This", "placeholder")
"{0} can be {1}".format("strings", "formatted")

关键字

"{name} wants to eat {food}".format(name="Bob", food="lasagna")

（3）序列类型

• list
• tuple
• range

（4）映射类型(dict)

（5）集合类型(set)

（6）布尔值bool(boolean)
返回结果只能是True,False

（7）二进制类型

1. bytes
2. bytearray
3. memoryview

注意：可以使用 type() 函数获取任何对象的数据类型

2. 数据类型的转换

1. eval():把字符串数据类型转换成原本数据类型
2. json.dumps()：把python对象(诸如dict/list/tuple/string等数据结构)转换为字符串(编码)
3. json.loads():把json化的字符串转换成对应的python对象(诸如dict/list/tuple/string等数据结构)(解码)
4. json.dump() 和 json.load() 用于处理文件，来编码和解码JSON数据

3. 运算符

（1）算数运算符

加号(Plus) +
1 + 1  # => 2

减号（Minus）-
8 - 1  # => 7

乘号(Multipy) *
10 * 2  # => 20

乘方（Power）**
2 ** 4  # => 16

模/取余操作 %
7 % 3  # => 1

补充：
a. 操作符 /（真除法），无论接受任何类型，结果都会保持小数部分。

4 / 2 # => 2.0
4 / 2.0 # => 2.0
5 / 2 # => 2.5

b. 操作符 // (Floor除法)，会截断余数直接返回一个整数，只有当接受类型中包含浮点型时，结果才会保留小数部分。

4 // 2 # => 2
5 // 2 # => 2
4 // 2.0 # => 2.0

c. 用括号强制改变算术的结合律

(1 + 3) * 2  # => 8

（2）比较运算符
相等判断用 ==

1 == 1  # => True
2 == 1  # => False

不等用 !=

1 != 1  # => False
2 != 1  # => True

更多的比较

1 < 10  # => True
1 > 10  # => False
2 <= 2  # => True
2 >= 2  # => True

比较可以串起来

1 < 2 < 3  # => True
2 < 3 < 2  # => False

（3）布尔值的操作或者叫逻辑运算
注意： “and” 和 “or” 是区分大小写的

True and False  # => False
False or True  # => True

注意布尔操作跟整数搅在一起的时候

0 and 2  # => 0
-5 or 0  # => -5
0 == False  # => True
2 == True  # => False
1 == True  # => True

用not来逻辑取反

not True  # => False
not False  # => True

任何的对象都可以在布尔值的上下文中使用，下面的值会被认为是false的：

- None
- zero of any numeric type (e.g., 0, 0L, 0.0, 0j)
- 任何数字类型的0 (比如, 0, 0L, 0.0, 0j)
- 空序列 (比如, '', (), [])
- 空的容器类型 (比如, {}, set())
- bool(0)  # => False
- bool("")  # => False

（4）位操作运算符
位运算符用于比较（二进制）数字

左移位（Left Shift）<<
2 << 2  # => 8
00000010向左移动2位：00001000 = 8(等效于右边加2个0，左边去2个0)

右移位（Right Shift）>>
与左移位相反

按位与（Bitwise AND）&
有1为1，都是0才为0

按位或（Bitwise OR）|
有1为1，都是0才为0

按位异或(Bit-wise XOR) ^
都是1或都是0返回0,否则返回1

按位取反(Bit-wise invert) ~
~ x = - (x+1)

（5）其他运算符

成员运算符 in，not in ：用于测试序列是否在对象中出现，返回值是True,False

身份运算符is，is not：身份运算符用于比较对象之间的相当性。
None是一个对象

None  # => None

使用 “is” 进行对象和None的比较

"etc" is None  # => False
None is None  # => True

“is”符号用来，在比较基本类型的时候可能用处不大，不过用在对象的比较方面却是很有用的。

字符串也是可以相加的!

"Hello " + "world!"  # => "Hello world!"

不用 ‘+’ 号也能加

"Hello " "world!"  # => "Hello world!"

还可以相乘

"Hello" * 3  # => "HelloHelloHello"

字符串可以当成是字符组成的列表

"This is a string"[0]  # => 'T'

二、序列

python3中采用input() 用来获取控制台的输入。
input() 将所有输入作为字符串看待，返回字符串类型。

# 函数语法
input([prompt])
# 参数说明：
# prompt: 可选，字符串，可作为一个提示语。

实例：

print("How old are you?")
age=input() 
 # => 18
print("So ,you are %r old" %(age))  
 # => So ,you are 18 old

#类型转换
b = int(input()) 
123
type(b)
<type 'int'>

给变量赋值之前是不需要声明的

some_var = 5  # 一般约定使用下划线去给变量名分词 lower_case_with_underscores
some_var  # => 5

访问没有定义的变量会抛出异常

some_other_var  # Raises a name error

if可以作为表达式使用
跟 C语言中 ‘?:’ 三元操作符等价

"yahoo!" if 3 > 2 else 2  # => "yahoo!"

1. 列表

列表：符号[ ]，一种有序和可更改的集合。允许重复的成员。

定义一个空列表和一个非空的列表
li = []
other_li = [4, 5, 6]

append()向列表的尾部添加元素，不能追加多个元素

li.append(1)  # li is now [1]
li.append(2)  # li is now [1, 2]
li.append(4)  # li is now [1, 2, 4]
li.append(3)  # li is now [1, 2, 4, 3]

insert()在特定的索引(index)处插入元素

li.insert(1, 2)  # li is now [1, 2, 3, 4, 5, 6] again

extend()一次可以插入多个数据,只能放在结尾

li.extend(other_li)  # Now li is [1, 2, 3, 4, 5, 6]
注意: li的值变化了的

返回第1个满足条件的值的索引

li.index(2)  # => 1
li.index(7)  # 抛出ValueError，因为7不在列表里

pop()将元素从列表尾部移除

li.pop()  # => 3 and li is now [1, 2, 4]
li.append(3)  # li is now [1, 2, 4, 3] again.

使用 del 来删除任意元素

del li[2]  # li is now [1, 2, 3]

remove()指定删除某个值

li.remove(2)  # li is now [1, 3, 4, 5, 6]
li.remove(2)  # 抛出ValueError, 2已经不在列表里了

访问列表项

通过引用索引号来访问列表项：
li[0]  # => 1

使用 = 可以给已经初始化过的索引赋新值
li[0] = 42
li[0]  # => 42
li[0] = 1  # 注意: 设置回原先的值

访问最后1个元素
li[-1]  # => 3

访问越界的话会抛出 IndexError

li[4]  # Raises an IndexError

使用切片(slice)语法可以访问列表中的部分元素

li[start:end:step]

实例：

li[1:3]  # => [2, 4]
忽略开头
li[:3]  # => [1, 2, 4]
忽略结尾
li[2:]  # => [4, 3]
每隔2个元素选择1个
li[::2]  # =>[1, 4]
反转列表的拷贝
li[::-1]  # => [3, 4, 2, 1]

列表可以相加

li + other_li  # => [1, 2, 3, 4, 5, 6]
注意: li 和 for other_li 的值没有变化的

移除第一个满足条件的值

li.remove(2)  # li is now [1, 3, 4, 5, 6]
li.remove(2)  # 抛出ValueError, 2已经不在列表里了

用 “in” 来检查元素是否在列表中存在

1 in li  # => True

用 “len()” 来返回列表的长度

len(li)  # => 6

总结：Python列表函数&方法

序号	函数及描述
1	len(list)列表元素个数
2	max(list)返回列表元素最大值
3	min(list)返回列表元素最小值
4	list(seq)将元组转换为列表
5	list.append(obj)在列表末尾添加新的对象
6	list.count(obj)统计某个元素在列表中出现的次数
7	list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
8	list.index(obj)从列表中找出某个值第一个匹配项的索引位置
9	list.insert(index, obj)将对象插入列表
10	list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
11	list.remove(obj)移除列表中某个值的第一个匹配项
12	list.reverse()反向列表中元素
13	list.sort( key=None, reverse=False)对原列表进行排序
14	list.clear()清空列表
15	list.copy()复制列表

2. 元组

元组(Tuples) ：符号( )，一种有序且不可更改的集合。允许重复的成员。

tup = (1, 2, 3)
tup[0]  # => 1
tup[0] = 3  # 抛出TypeError异常

你可以在元组上做下面一些的列表操作

len(tup)  # => 3
tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
tup[:2]  # => (1, 2)
2 in tup  # => True

你可以从元组(或列表) 取出变量

a, b, c = (1, 2, 3)  # a is now 1, b is now 2 and c is now 3
d, e, f = 4, 5, 6  # 你都可以省略括号
如果你不加括号的话，默认情况下会创建元组
g = 4, 5, 6  # => (4, 5, 6)
看一下，交换变量的值那是相当容易的
e, d = d, e  # d is now 5 and e is now 4

注意:元组里面只有一个元素，需要加逗

3. 字典

字典（Dictionary）：符号{ }，一个无序，可变和有索引的集合。没有重复的成员。用来存储属性名(key)和属性值(value)的

定义一个空字典和一个非空的字典
empty_dict = {}
filled_dict = {"one": 1, "two": 2, "three": 3}

用[]来查找属性的值(value)

filled_dict["one"]  # => 1

用"keys()"来返回所有key的列表

filled_dict.keys()  # => ["three", "two", "one"]

注意 - 字典key的顺序是不保证的

"values()"返回所有值(value)的列表

filled_dict.values()  # => [3, 2, 1]

注意 - 排序问题跟上面的类似

“items()” 返回所有的键值对(key-value)的元组组成的列表

filled_dicts.items()  # => [("one", 1), ("two", 2), ("three", 3)]

用"in"来判断某个属性名/某个键是否存在

"one" in filled_dict  # => True
1 in filled_dict  # => False

访问不存在的属性名/键的时候会抛出 KeyError

filled_dict["four"]  # KeyError

用"get()"方法可以避免 KeyError

filled_dict.get("one")  # => 1
filled_dict.get("four")  # => None

get支持当属性名/键不存在的时候返回1个设定的默认值

filled_dict.get("one", 4)  # => 1
filled_dict.get("four", 4)  # => 4
# 注意: filled_dict.get("four") 仍然是 => None
 (get 并不会设置字典的值)

为某个属性名/键赋值跟列表赋值的方式差不多

filled_dict["four"] = 4  # now, filled_dict["four"] => 4

总结：python中字典内置函数&方法

序号	函数及描述
1	len(dict)计算字典元素个数，即键的总数。
2	str(dict)输出字典，以可打印的字符串表示。
3	type(variable)返回输入的变量类型，如果变量是字典就返回字典类型。
4	radiansdict.get(key, default=None)返回指定键的值，如果值不在字典中返回default值
5	key in dict如果键在字典dict里返回true，否则返回false
6	radiansdict.items()以列表返回可遍历的(键, 值) 元组数组
7	radiansdict.keys()返回一个迭代器，可以使用 list() 来转换为列表
8	radiansdict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	radiansdict.update(dict2)把字典dict2的键/值对更新到dict里
10	radiansdict.values()返回一个迭代器，可以使用 list() 来转换为列表
11	pop(key[,default])删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12	popitem()随机返回并删除字典中的最后一对键和值。
13	radiansdict.clear()删除字典内所有元素
14	radiansdict.copy()返回一个字典的浅复制
15	radiansdict.fromkeys()创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

4. 集合

集合（set）：一个无序和无索引的集合。没有重复的成员。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

>>>basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

添加元素
语法格式如下：

>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

s.update( x )

移除元素
语法格式如下：

s.remove( x )
# 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

s.discard( x )
# 如果元素不存在，不会发生错误

s.pop()
随机删除集合中的一个元素

实例：

实例1：
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.remove("Taobao")
>>> print(thisset)
{'Google', 'Runoob'}
>>> thisset.remove("Facebook")   # 不存在会发生错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Facebook'
>>>
实例2：
>>>thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.discard("Facebook")  # 不存在不会发生错误
>>> print(thisset)
{'Taobao', 'Google', 'Runoob'}

两个集合间的运算

# 用 & 来取交集
other_set = {3, 4, 5, 6}
filled_set & other_set  # => {3, 4, 5}

# 用 | 取并集
filled_set | other_set  # => {1, 2, 3, 4, 5, 6}

# 用 - 来取差集
{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}

# 用 ^ 取对称差集
{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}

判断左边的集合是不是右边的超集
{1, 2} >= {1, 2, 3}  # => False

判断左边的集合是不是右边的子集
{1, 2} <= {1, 2, 3}  # => True

清空集合

s.clear()

用in来判断元素在集合中是否存在

2 in filled_set  # => True
10 in filled_set  # => False

总结：python中集合内置函数

序号	函数及描述
1	add() 为集合添加元素
2	clear() 移除集合中的所有元素
3	copy() 拷贝一个集合
4	difference() 返回多个集合的差集
5	difference_update() 移除集合中的元素，该元素在指定的集合也存在。
6	discard() 删除集合中指定的元素
7	intersection() 返回集合的交集
8	intersection_update() 返回集合的交集。
9	isdisjoint() 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
10	issubset() 判断指定集合是否为该方法参数集合的子集。
11	issuperset() 判断该方法的参数集合是否为指定集合的子集
12	pop() 随机移除元素
13	remove() 移除指定元素
14	symmetric_difference() 返回两个集合中不重复的元素集合。
15	symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
16	union() 返回两个集合的并集
17	update() 给集合添加元素