一、 Python3 中有六个标准的数据类型：

Number（数字）、String（字符串）、List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）

Python3 的六个标准数据类型中：
不可变数据：Number（数字）、String（字符串）、Tuple（元组）；
可变数据：List（列表）、Dictionary（字典）、Set（集合）。

1. Number

Python3 支持 int、float、bool、complex（复数）。

a, b, c, d = 20, 5.5, True, 4+3j
print(type(a), type(b), type(c), type(d))
# 内置的 type() 函数可以用来查询变量所指的对象类型。
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

2. String

原文：http://www.runoob.com/python3/python3-string.html

a. 定义及基本操作（+，*，读取方式）

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

# 三种定义字符串的方法
'字符串1'
"字符串2"

'''
字符串3
字符串4
字符串5
'''

# 读取方式：下标索引和切片
var1 = 'Hello'
var2 = "Python"
print ("var1[0]: ", var1[0])          # H
print ("var2[1:5]: ", var2[1:5])      # ytho

# 使用 + 连接字符串
print(var1 + var2)      # Hello Python

# 使用 * v 重复字符串
print(var1 ** 3)        # HelloHelloHello

# 更新
var2 = "new String"
print(var2)             # new String

b. 字符串相关方法

使用反斜杠(\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

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

另外，反斜杠()可以作为续行符，表示下一行是上一行的延续。也可以使用 “”"…""" 或者 ‘’’…’’’ 跨越多行。

字符串运算符：

注意：
1、反斜杠可以用来转义，使用r可以让反斜杠不发生转义。
2、字符串可以用+运算符连接在一起，用*运算符重复。
3、Python中的字符串有两种索引方式，从左往右以0开始，从右往左以-1开始。
Python 没有单独的字符类型，一个字符就是长度为1的字符串。
4、Python中的字符串不能改变。向一个索引位置赋值，比如word[0] = 'm’会导致错误。

3. List

a. 标志

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
和字符串一样，list可以被索引和切片，List可以使用+操作符进行拼接。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
索引值以 0 为开始值，-1 为从末尾的开始位置。

b. 基本操作

· 创建

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

list1 = ['Hello', 'World', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

访问列表中的值：

list1 = ['Hello', 'World', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
 
print ("list1[0]: ", list1[0])            # list1[0]:  Hello
print ("list2[1:5]: ", list2[1:5])        # list2[1:5]:  [2, 3, 4, 5]

· append( )

list1 = ['aaa', 'bbb', 'ccc']
list1.append('ddd')
print ("更新后的列表 : ", list1)
# ['aaa', 'bbb', 'ccc', 'ddd']

· pop( )

# list.pop([index=-1])  index -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

list1 = ['aaa', 'bbb', 'ccc']

list1.pop()
print ("列表现在为 : ", list1)
# ['aaa', 'bbb']

list1.pop(1)
print ("列表现在为 : ", list1)
# ['bbb']

· del( )

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

list = ['aaa', 'bbb', 2019, 2020]
 
del list[2]
print ("删除第三个元素 : ", list)
# ['aaa', 'bbb', 2020]

用来删除列表元素的方法还有一个。
remove() 函数用于移除列表中某个值的第一个匹配项。

aList = ['aaa', 'bbb', 'ccc', 'bbb'];
aList.remove('bbb');

print "List : ", aList;
# ['aaa', 'ccc', 'bbb']

· 拷贝

copy() 函数用于复制列表，类似于 a[:]。
无参数，返回复制后的新列表。

# 往列表中设置不同类型的值（由于元组不可修改，便没有放进去），观察两种拷贝方法的差异。
a = [2333, 'a', [0, 1, 2], {'a', 'b', 'c'}, {'name': 'python', 'age': 3}]
b = a
c = a.copy()

# 数值
del a[0]  
'''
	各变量值为：
	a = ['a', [0, 1, 2], {'c', 'b', 'a'}, {'name': 'python', 'age': 3}]
	b = ['a', [0, 1, 2], {'c', 'b', 'a'}, {'name': 'python', 'age': 			
	c = [2333, 'a', [0, 1, 2], {'c', 'b', 'a'}, {'name': 'python', 'age': 3}]
'''

# 字符串
del a[0]
'''
	各变量值为：
	a =  [[0, 1, 2], {'b', 'a', 'c'}, {'name': 'python', 'age': 3}]
	b =  [[0, 1, 2], {'b', 'a', 'c'}, {'name': 'python', 'age': 3}]
	c =  [2333, 'a', [0, 1, 2], {'b', 'a', 'c'}, {'name': 'python', 'age': 3}]
'''

# 列表
del a[0][0]
'''
	各变量值为：
	a = [[1, 2], {'c', 'a', 'b'}, {'name': 'python', 'age': 3}]
	b = [[1, 2], {'c', 'a', 'b'}, {'name': 'python', 'age': 3}]
	c = [2333, 'a', [1, 2], {'c', 'a', 'b'}, {'name': 'python', 'age': 3}]
'''

# 集合
a[1].remove('a')
'''
	各变量值为：
	a = [[1, 2], {'c', 'b'}, {'name': 'python', 'age': 3}]
	b = [[1, 2], {'c', 'b'}, {'name': 'python', 'age': 3}]
	c = [2333, 'a', [1, 2], {'c', 'b'}, {'name': 'python', 'age': 3}]
'''

# 字典
a[2]['age'] = 4
'''
	各变量值为：
	a = [[1, 2], {'c', 'b'}, {'name': 'python', 'age': 4}]
	b = [[1, 2], {'c', 'b'}, {'name': 'python', 'age': 4}]
	c = [2333, 'a', [1, 2], {'c', 'b'}, {'name': 'python', 'age': 4}]
'''
'''
	以上可以看出，使用 = 直接赋值，是引用赋值，a影响了b（可以试试改变b，观察a的变化）。
	然而copy() 只是是浅拷贝，修改列表中的数值、字符串不会互相影响，但是修改列表里面的集合、字典、列表，则会受到a的影响。
'''

c. 列表相关方法

原文：http://www.runoob.com/python3/python3-list.html

4. Tuple

a. 标志

Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。

b. 基本操作（创建及不可变性）

创建：
元组创建很简单，只需要在()中添加元素，并使用逗号隔开即可。

tup1 = ('aaa', 'bbb', 2019, 2020);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";   #  不需要括号也可以
type(tup3)
# <class 'tuple'>

# 创建空元组
tup1 = ();

# 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
tup1 = (50)
type(tup1)     # 不加逗号，类型为整型
# <class 'int'>
 
tup1 = (50,)
type(tup1)     # 加上逗号，类型为元组
# <class 'tuple'>

不可变性：

tup = (1, 2, 3, 4, 5, 6)
print(tup[0])
# 1
print(tup[1:5])
(2, 3, 4, 5)
tup[0] = 11  # 修改元组元素的操作是非法的

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表，可以使用下标索引来访问元组中的值，可以用“+”连接，存储到另一个变量中，也可以整个元组全部删除。

string、list 和 tuple 都属于 sequence（序列）。
注意：
1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。

5. Set

a. 特性

集合（set）是一个无序的不重复元素序列。

b. 创建

可以使用大括号 { } 或者 set() 函数创建集合，集合存放不可变类型（字符串、数字、元组）注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student)   # {'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}      输出集合，重复的元素被自动去掉
 
# 成员测试
if 'Rose' in student :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')
# Rose 在集合中

# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)         # {'b', 'a', 'c', 'r', 'd'}
print(a - b)     # {'b', 'd', 'r'}                             a 和 b 的差集
print(a | b)     # {'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}    a 和 b 的并集
print(a & b)     # {'a', 'c'}                                  a 和 b 的交集
print(a ^ b)     # {'l', 'r', 'z', 'm', 'b', 'd'}              a 和 b 中不同时存在的元素

# 类似列表推导式，同样集合支持集合推导式
a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)         # {'r', 'd'}

c. 方法

'''1.添加元素(add（）、update（）  如果元素已存在，则不进行任何操作)。'''
# add()，添加单个元素
this_set = set(("aa", "bb", "cc"))
this_set.add('dd')
print(this_set)              # {"aa", "bb", "cc", "dd"}

# update（），添加多个元素
this_set.update({1,3})
print(this_set)              # {"aa", "bb", "cc", "dd", 1, 3}

'''2.移除元素（remove()、discard()）'''
# remove()，如果元素不存在，则会发生错误
this_set.remove('dd')
print(this_set)              # {"aa", "bb", "cc", 1, 3}

this_set.remove('dd')
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# KeyError: 'dd'

# discard()，如果元素不存在，则会发生错误
this_set.discard("dd")
print(this_set)              # {"aa", "bb", "cc", 1, 3}

# pop()，也可以设置随机删除集合中的一个元素，多次执行测试结果都不一样。
# 然而在交互模式，pop 是删除集合的第一个元素（排序后的集合的第一个元素）。
this_set.discard()            # {"bb", "cc", 1, 3}

'''3.计算集合元素个数（len(set_name)）'''
len(this_set)                 # 4


'''4.清空集合（set_name.clear()）'''
this_set.clear()
print(this_set)               # set()

'''判断元素是否在集合中存在，存在返回 True，不存在返回 False。(x in set_name)'''
'bb' in this_set              # True
'aa' in this_set              # False


'''
Python交互模式主要是为了调试Python代码用的。
在命令行模式下，可以直接运行.py文件。
在写完一行代码，回车后会立即执行并得到结果的就是Python交互模式。
命令行模式不能运行Python代码。
'''

http://www.runoob.com/python3/python3-set.html

6. Dictionary

a. 定义

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中。

b. 创建

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"
 
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
 
 
print (dict['one'])       # 1 - 菜鸟教程                                                输出键为 'one' 的值
print (dict[2])           # 2 - 菜鸟工具                                                输出键为 2 的值
print (tinydict)          # {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}   输出完整的字典
print (tinydict.keys())   # dict_keys(['name', 'code', 'site'])                       输出所有键
print (tinydict.values()) # dict_values(['runoob', 1, 'www.runoob.com'])              输出所有值

另外，字典类型也有一些内置的函数，例如clear()、keys()、values()等。
注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 {}。

c. 字典键的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

1. 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住。

dict = {'Name': 'python', 'Age': 3, 'Name': 'Go'}
print (dict['Name'])            # Go

2. 键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行。

dict = {['Name']: 'python', 'Age': 3, 'Name': 'Go'}
print (dict['Name'])
# Traceback (most recent call last):
#   File "test.py", line 2, in <module>
#     dict = {['Name']: 'python', 'Age': 3}
# TypeError: unhashable type: 'list'

d. 字典的方法

'''1.访问字典里的值'''
dict = {'Name': 'python', 'Age': 3}
print (dict['Name'])        # python

# 如果用字典里没有的键访问数据，会输出错误
print (dict['Friend']) 
# Traceback (most recent call last):
#   File "test.py", line 5, in <module>
#     print (dict['Alice'])
# KeyError: 'Friend'

'''修改字典'''
# 修改
dict['Age'] = 4
print (dict['Age'])         # 4

# 添加
dict['Friend'] = 'Javascript'
print (dict['Friend'])      # Javascript

# 删除
del dict['Name']            # 删除键 'Name'    {'Age': 3, 'Friend': 'Javascript'}
dict.clear()                # 清空字典         {}
del dict                    # 删除字典

二、字符串格式化问题

Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
# 我叫 小明 今年 10 岁!

python字符串格式化符号:

格式化操作符辅助指令:

三、判断语句（要求掌握多条件判断）

判断语句（条件语句）是通过一条或多条语句的执行结果（True或者False）来决定执行的代码块。

num = 10
if num < 20:
    print("num小于20")
elif num > 80:
    print("num大于80")
else:
    print("num在20到80之间")
    
# 在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。
if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

注意：
1、每个条件后面要使用冒号 : ，表示接下来是满足条件后要执行的语句块。
2、if 可以单独使用，也可以和elif、else搭配使用，但是后两个必须要同 if 搭配使用。
3、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
4、在Python中没有switch – case语句。

if中常用的操作运算符

四、三目表达式

使用一行代码快速判断，替换复杂的多行if语句，使得代码简单可维护。

num = 3
result = 1 if num > 1 else 3

五、循环语句

Python中的循环语句有 for 和 while。

while

n = 100
sum = 0
counter = 1

while counter <= n:
    sum = sum + counter
    counter += 1
 
print("1 到 %d 之和为: %d" % (n,sum))           # 1 到 100 之和为: 5050

# 当while后面的条件表达式永远不为 false 时，实现无限循环，无限循环在服务器上客户端的实时请求非常有用。


# 类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中。
while (flag): print ('欢迎访问菜鸟教程!')

while…else…

count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

'''
0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5
'''

for

Python for循环可以遍历任何序列的项目（除了数值的任何其他数据类型）。

list = [1, 2, 3, 4]
for i in list:
print(i)
'''
1
2
3
4
'''

for 实例中使用了 break 语句，break 语句用于跳出当前循环体

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")

continue语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

for letter in 'Hi':                    # 第一个实例
   if letter == 'H':                   # 字母为 o 时跳过输出
      continue
   print ('当前字母 :', letter)         # i

循环语句可以有 else 子句，它在穷尽列表（以for循环）或条件变为 false （以while循环）导致循环终止时被执行，但循环被break终止时不执行。

for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, '等于', x, '*', n//x)
            break
    else:
        # 循环中没有找到元素
        print(n, ' 是质数')
'''
2  是质数
3  是质数
4 等于 2 * 2
5  是质数
6 等于 2 * 3
7  是质数
8 等于 2 * 4
9 等于 3 * 3
'''

如果你需要遍历数字序列，可以使用内置 range() 函数，它会生成数列。

for i in range(5):
	print(i)
'''
0
1
2
3
4
'''

# 也可以使用range指定区间的值
for i in range(5,8) :
    print(i)

'''
5
6
7
'''

# 也可以使range以指定数字开始并指定不同的增量（甚至可以是负数，有时这也叫做'步长'）
for i in range(1, 10, 3) :
    print(i)

'''
1
4
7
'''

for i in range(-10, -100, -30) :
    print(i)
 
'''
-10
-40
-70
'''

# 还可以使用range()函数来创建一个列表
list(range(5))
# [0, 1, 2, 3, 4]

pass 语句

pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句。

for letter in 'hello': 
   if letter == 'l':
      pass
      print ('执行 pass 块')
   print (letter)
print ("Done!")

'''
h
e
执行 pass 块
l
执行 pass 块
l
o
Done!
'''