python笔记（二）

Python 基本数据类型

说明	类型
文本类型	str（字符串）
数值类型	int（长整型）, float（浮点数）, complex（复数）
序列类型	list（列表）, tuple（元组）, range（整数序列）
映射类型	dict（字典）
集合类型	set（集合）, frozenset（冻结集合）
布尔类型	bool（布尔值）
二进制类型	bytes, bytearray, memoryview

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

x = 10
print(type(x))

Python3 的六个标准数据类型

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

Number（数字）

int、float、bool、complex（复数）

Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加
Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。

bool（布尔类型）

在 Python 中，True 和 False 都是关键字，表示布尔值。

下例会返回 False：

bool(False)
bool(None)
bool(0)
bool("")
bool(())
bool([])
bool({})

数值运算

>>> 5 + 4  # 加法
9
>>> 4.3 - 2 # 减法
2.3
>>> 3 * 7  # 乘法
21
>>> 2 / 4  # 除法
0.5
>>> 7//2 # 地板除（取整除），得到的并不一定是整数类型的数，它与分母分子的数据类型有关系
3
>>> 7.0//2
3.0
>>> 7//2.0
3.0
>>> 17 % 3 # 取余 
2
>>> 2 ** 5 # 乘方 幂运算
32

String（字符串）

Python中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

1. 如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r ( r 指 raw，即 raw string)

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

2. 字符串的截取的语法格式如下：

变量[头下标:尾下标] #索引值以 0 为开始值，-1 为从末尾的开始位置。

3. 加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数
4. Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = ‘m’ 会导致错误。
5. python三引号允许一个字符串跨多行

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)

6. Python 字符串格式化：在文本中添加占位符（花括号 {}），然后通过 format() 方法运行值

quantity = 3
itemno = 567
price = 52
myorder = "I want {} pieces of item number {} for {:.2f} dollars."
print(myorder.format(quantity, itemno, price))
#I want 3 pieces of item number 567 for 52.00 dollars.

age = 63
name = "Bill"
txt = "His name is {1}. {1} is {0} years old."
print(txt.format(age, name))
#His name is Bill. Bill is 63 years old.

List（列表）

1. List（列表） 是 Python 中使用最频繁的数据类型
2. 列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
3. 与Python字符串一样，列表同样可以被索引和截取
4. 与Python字符串不一样的是，列表中的元素是可以改变 的
5. 使用 append() 方法来添加列表项

list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)

6. 可以使用 del 语句来删除列表的的元素

list = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)

Tuple（元组）

1. 元组写在 小括号 () 里，元素之间用逗号隔开
2. 与Python字符串一样，元组同样可以被索引和截取
3. 与Python字符串一样，元组的元素不能修改，所指向的内存中的内容不可变

>>> 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    # 内存地址不一样了

4. 包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号。在没有逗号的情况下，Python会将括号解释为数学运算中的括号，而不是元组的表示。

Set（集合）

1. Python 中的集合（Set）是一个无序的不重复元素序列。
2. 在 Python 中，集合使用 大括号 {} 表示，元素之间用逗号 , 分隔。
3. 集合中的元素不会重复，重复的元素被自动去掉。 并且可以进行交集、并集、差集等常见的集合操作

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

4. 使用 set() 函数创建集合。 注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
5. 集合（Set）中的元素不可以被索引

Dictionary（字典）

1. 字典（dictionary）是Python中另一个非常有用的内置数据类型
2. 字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合
3. 键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。
4. 使用大括号 { } 创建空字典
5. 构造函数 dict() 可以直接从键值对序列中构建字典

>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}

bytes

1. 在 Python3 中，bytes 类型表示的是不可变的二进制序列（byte sequence）。
2. bytes 类型通常用于处理二进制数据，比如图像文件、音频文件、视频文件等等。
3. bytes 类型中的元素是整数值，因此在进行比较操作时需要使用相应的整数值。

x = b"hello"
if x[0] == ord("h"): #ord() 函数用于将字符转换为相应的整数值
    print("The first element is 'h'")

range

1. range()是python的一个内置函数,用来创建一个 整数序列，常用于for循环中。
2. range函数语法格式如下

range(start, stop[, step])

'''
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
'''

>>>range(10)        # 从 0 开始到 9
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)     # 从 1 开始到 10
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)  # 步长为 5
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)  # 步长为 3
[0, 3, 6, 9]
>>> range(0, -10, -1) # 负数
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

3. 需要注意的是,range对象不是一个列表,而是一个只能迭代的”可迭代对象”。实际上range使用了一种名为”迭代器”的技术来高效生成数值序列,而没有真的先创建一个完整的列表再返回,这才保证了range占用内存很小。