本节的主要目的是介绍一些Python的基础知识。
注释的作用是通过使用自己熟悉的语言，在程序中对某些代码进行标注说明，它能够大大增强程序的可读性。主要的注释方式有三种：单行注释、多行注释和中文注释。 单行注释：以#开头，#右边的所有东西当作说明，而不是真正要执行的程序，起辅助说明作用，代码如下：
# 这是注释，一般写一些下面代码块的功能说明
print('hello world')
hello world
多行注释：以```开头和结尾，中间部分是注释内容，一般在内容较多，一行写不下的情况下进行标注说明，代码如下：
'''
这是多行注释，可以写很多很多行的功能说明哦
哈哈
哈
哈哈哈哈哈哈哈哈…
'''
print("多行注释")
多行注释
在程序中，如果需要对2个数据进行求和，那么该怎样做呢？ 类比一下现实生活中，如果去超市买两个商品，我们往往需要一个购物袋来存储商品，所有的商品都购买完成后，在收银台进行结账即可。 在程序中，如果需要对2个数据进行求和的话，也需要把这些数据先存储起来，然后把它们累加起来即可。 在Python中，存储一个数据，就需要一个变量，代码如下：
num1 = 7 #num1就是一个变量，就像一个购物袋
num2 = 9 #num2也是一个变量
#把num1和num2这两个"购物袋"中的数据进行累加，然后放到 result变量中
result = num1 + num2
print(result)
16
所谓变量，可以理解为购物袋，如果需要存储多个数据，最简单的方式是用多个变量。想一想：我们应该让变量占用多大的空间，保存什么样的数据呢？ 这就是下面要介绍的六大数据类型。
对于购物袋来说，一般也是有很多种类的，比如小袋子、中袋子和大袋子。每个类型经常装的物品也会有区别。
那么对于变量来说也是一样的，Python里面有六大基础的数据类型，可以更充分地利用内存空间以及更有效率地管理内存。六大数据类型分别为：Numbers（数字）、String（字符串）、List（列表）、Tuple（元组）、Dictionary（字典）和Set（集合）。
数字数据类型下有三个子类型：
a= 1 # Int类型数据赋值
print(type(a))
b= 1.0 # Float类型数据赋值
print(type(b))
c= 3e+26J # Complex类型数据赋值
print(type(c))
<class 'int'> <class 'float'> <class 'complex'>
有时候需要对数据内置的类型进行转换，数据类型的转换，只需要将数据类型作为函数名即可：
①：int(x)将x转换为一个整数。
②：float(x)将x转换到一个浮点数。
③：complex(x)将x转换到一个复数，实数部分为x，虚数部分为 0。
④：将x和y转换到一个复数，实数部分为x，虚数部分为y。x和y是数字表达式。
将浮点数变量a转换为整数，代码如下：
a = 1.0
int(a)
1
(2)数字数据类型的运算：
Python 解释器可以作为一个简单的计算器，在解释器里输入一个表达式，它将输出表达式的值。 表达式的语法很直白，“+”、“-”、“*”、“/”和其他语言（如Pascal或C）里一样。但是有几个值得注意的地方：
①在不同的机器上浮点运算的结果可能会不一样。
②在整数除法中，除法“/” 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符“//”。
③ “//”得到的并不一定是整数类型的数，它与分母分子的数据类型有关系（例如，7//2.0>>>3.0）。
④Python 可以使用“**”操作来进行幂运算。
⑤变量在使用前必须先“定义”（即赋予变量一个值），否则会出现错误。
⑥不同类型的数混合运算时会将整数转换为浮点数。
Python内置的数字类型数学函数见下表。
(3)Python内置的数字类型随机数函数：
随机函数可以用于数学、游戏、安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高程序的安全性，随机函数说明见下表
字符串是Python中最常用的数据类型。读者可以使用引号（' 或 "）来创建字符串。 创建字符串很简单，只要为变量分配一个值即可，代码如下：
var1 = 'Hello World!'
var2 = "VenusAI"
(1)Python访问字符串中的值：
Python访问子字符串，可以使用方括号“[]”来截取字符串，字符串的截取的语法格式为：变量名[头下标: 尾下标: 步长]，左闭右开，代码如下：
var1 = 'Hello World!'
var2 = "VenusAI"
print ("var1[-1]: ", var1[-2])
print ("var2[::2]: ", var2[::2])
var1[-1]: d var2[::2]: VnsI
var1 = 'Hello World!'
print ("已更新字符串 : ", var1[:6] + 'VenusAI!')
已更新字符串 : Hello VenusAI!
可以按照某个元素对字符串进行切分，方法语法：字符串.split(str=" ")，代码如下：
value = 'Hello_World!'
print ("已更新字符串 : ", value.split('_'))
已更新字符串 : ['Hello', 'World!']
以“_”为分隔符切片字符串value，返回一个列表来存储分割后的字符串。
在计算机中，有些字符是有特殊含义的，例如换行符、制表符、引号等等。如果我们想要表示这些字符本身，而不是它们的特殊含义，就需要使用转义字符来进行表示。Python用反斜杠“\”转义字符，常见的如下：
①(在行尾时) 表示续行符。
②\n：表示换行符，将光标移动到下一行开头。
③\t：表示制表符，将光标移动到下一个制表符位置。
④\r：表示回车符，将光标移动到本行开头。
⑤\b：表示退格符，将光标退回到前一个位置。
⑥\f：表示换页符，将光标移动到下一页开头。
⑦\'：表示单引号本身。
⑧\"：表示双引号本身。
代码如下：
#第3章/zfc.py
# \\ 表示反斜杠符号
print("\\")
# \n' 表示换行
print("\\n")
# \" 表示双引号
print("\"")
# "
\ \n "
#第3章/zfc.py
a = 'hello'
b = 'Python'
# + 字符串连接
print(a + b)
# helloPython
# * 重复输出字符串
print(a*2)
# hellohello
helloPython hellohello
Python支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符%s的字符串中。 在Python中，字符串格式化使用与C语言中sprintf函数一样的语法，代码如下：
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
我叫 小明 今年 10 岁!
Python常用的字符串格式化符号见下表。
序列是Python中最基本的数据结构。
序列中的每个值都有对应的位置值，称之为索引，第一个索引是0，第二个索引是1，依此类推，List也有负索引。
Python 有6个序列的内置类型，但最常见的是列表类型。
列表可以进行的操作包括索引、切片、加、乘和检查元素。
此外，Python 已经内置函数来确定序列的长度以及确定最大和最小的元素的方法。
列表的数据项不需要具有相同的类型，可以接受任何变量类型。
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。代码如下：
list1 = ['Python2.0', 'Guido', 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
与字符串的索引一样，列表索引从0开始，第二个索引是 1，依此类推。 通过索引列表可以进行截取、组合等操作，代码如下：
list = ["a", "b", "c", "d"]
print( list[0] ) # a
print( list[1] ) # b
print( list[-2] ) # c
print( list[-3] ) # b
a b c b
除了使用下标索引来访问列表中的值，也同样可以使用方括号 [头下标: 尾下标]，左闭右开的形式截取字符，代码如下：
nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4]) # 10 20 30 40
print(nums[2:-3]) # 30 40 50 60
[10, 20, 30, 40] [30, 40, 50, 60]
可以对列表的数据项进行修改或更新，也可以使用append()方法来添加列表项，代码如下：
#第1章/libiao.py
list = ['Python2.0', 'VenusAI', 2000]
print ("第2个元素为 : ", list[1])
list[1] = 'Community'
print ("更新后的第2个元素为 : ", list[1])
'''
第2个元素为：Guido
更新后的第2个元素为：Community
'''
list = ['Alibaba', 'Tencent']
list.append('Baidu')
print ("更新后的列表 : ", list)
第2个元素为 : VenusAI 更新后的第2个元素为 : Community 更新后的列表 : ['Alibaba', 'Tencent', 'Baidu']
可以使用del语句来删除列表中的元素，代码如下：
#第1章/libiao.py
list = ['Python2.0', 'VenusAI', 2000]
print ("原始列表 : ", list)
del list[2]
print ("删除第3个元素 : ", list)
原始列表 : ['Python2.0', 'VenusAI', 2000] 删除第3个元素 : ['Python2.0', 'VenusAI']
使用嵌套列表即在列表里创建其他列表，代码如下：
a = [1, 2, 3]
b = ['a', 'b']
x = [a, b]
print(x)
# [[1, 2, 3], ['a', 'b']]
[[1, 2, 3], ['a', 'b']]
列表比较则需要引入Operator模块的eq()方法，代码如下：
#第1章/libiao.py
# 导入 operator 模块
import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))
operator.eq(a,b): False operator.eq(c,b): True
insert()函数用于将指定对象插入列表的指定位置。代码如下： list.insert(index, obj)
参数： ①index：对象obj需要插入的索引位置。 ②obj：要插入列表中的对象。 该方法没有返回值，但会在列表指定位置插入对象。insert()函数的使用代码如下：
list = ['Alibaba', 'Tencent']
list.insert(1, 'Baidu')
print ('列表插入元素后为 : ', list)
列表插入元素后为 : ['Alibaba', 'Baidu', 'Tencent']
count()方法用于统计某个元素在列表中出现的次数。代码如下：list.count(obj)
参数obj表示要统计的列表对象，返回元素在列表中出现的次数。count()函数的使用代码如下：
list = [1, 2, 1, 1, 2, 3, 4]
print("3的元素个数: ", list.count(3))
# 1的元素个数: 3
3的元素个数: 1
①参数key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。例如，如果你有一个包含字符串的列表，你可以使用 key 参数来指定按字符串长度排序。 ②参数reverse：排序规则，reverse = True，降序；reverse = False，升序（默认）。 该方法没有返回值，但是会对列表的对象进行排序。sort()函数的使用代码如下：
list = ["VenusAI", "www.aideeplearning.cn", "aideeplearning"]
list.sort(key=len)
print("排序后的list: ", list)
排序后的list: ['VenusAI', 'aideeplearning', 'www.aideeplearning.cn']
tuple = ()
注意：元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用，代码如下：
tup1 = (50)
print(type(tup1)) # 不加逗号，类型为整型
tup2 = (50,)
print(type(tup2)) # 加上逗号，类型为元组
<class 'int'> <class 'tuple'>
增：元组与字符串、列表类似，且可以进行截取、组合等，代码如下：
#第1章/yuanzu.py
tup1 = (1, 2)
tup2 = (3, 4)
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3*2)
# (1, 2, 3, 4)
(1, 2, 3, 4, 1, 2, 3, 4)
删：元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组，代码如下：
tup = (1, 2, 3, 4)
print(tup)
del tup
print("删除后的元组tup:", tup)
(1, 2, 3, 4)
--------------------------------------------------------------------------- NameError Traceback (most recent call last) Cell In[50], line 4 2 print(tup) 3 del tup ----> 4 print("删除后的元组tup:", tup) NameError: name 'tup' is not defined
改：元组中的元素值是不允许修改的，代码如下：
#第1章/yuanzu.py
tup = (3,.14)
# 以下操作是非法的
tup[0] = 4
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Cell In[51], line 4 2 tup = (3,.14) 3 # 以下操作是非法的 ----> 4 tup[0] = 4 TypeError: 'tuple' object does not support item assignment
查：元组与字符串类似，元组的访问从下标索引从0开始，当然，也可以使用负索引，代码如下：
#第1章/yuanzu.py
tup1 = (1, 2, 3, 4, 5)
tup2 = ('a', 'b', 'c', 'd', 'e')
print("tup1[0]: ", tup1[0])
print("tup2[1:4]: ", tup2[1:4])
tup1[0]: 1
tup2[1:4]: ('b', 'c', 'd')
#第1章/yuanzu1.py
tup = (1, 2, 3, 4, 5, 6)
print(tup)
print(id(tup)) # 查看内存地址
tup = (1,)
print(tup)
print(id(tup))
(1, 2, 3, 4, 5, 6) 2410126556800 (1,) 2410127458800
从以上实例可以看出，重新赋值的元组（tup），绑定到新的对象了，不是修改了原来的对象。
字典是另一种可变容器模型，且可存储任意类型对象。 字典的存储单元是成对出现的key: value，用冒号“:”分割；每个对之间用逗号“,”分割，整个字典包括在花括号“{}”中，代码如下：d = {key1: val1, key2: val2}
# 创建空字典使用大括号{}创建
emptyDict = {}
# 也可以使用函数dict()构建
emptyDict = dict()
字典中，键必须是唯一的，但值可以不唯一。且值可以取任何数据类型，但是键必须是不可变的数据类型，如字符串、数字。代码如下：
tinydict = {'name': 'VenusAI', 'likes': 123, 'url': 'www.aideeplearning.cn'}
函数dict.keys()或dict.values()可以返回字典的键值对，代码如下：
#第1章/zidian.py
d = {"name":"VenusAI", "age":7}
print(d.items() )
print(d.keys() )
print(d.values() )
dict_items([('name', 'VenusAI'), ('age', 7)])
dict_keys(['name', 'age'])
dict_values(['VenusAI', 7])
增：向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对，代码如下：
#第1章/zidian.py
tinydict = {'Name': 'VenusAI', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 9 # 更新Age
tinydict['Web'] = "www.aideeplearning.cn" # 添加信息
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['Web']: ", tinydict['Web'])
print(tinydict)
tinydict['Age']: 9
tinydict['Web']: www.aideeplearning.cn
{'Name': 'VenusAI', 'Age': 9, 'Class': 'First', 'Web': 'www.aideeplearning.cn'}
删：能删单一的元素，也能清空字典，清空只需一项操作。显式删除一个字典用del命令，代码如下：
tinydict = {'Name': 'VenusAI', 'Age': 7, 'Web': 'www.aideeplearning.cn'}
print(tinydict)
del tinydict['Name'] # 删除键 'Name'
print(tinydict)
tinydict.clear() # 清空字典
print(tinydict)
del tinydict # 删除字典
print(tinydict)
{'Name': 'VenusAI', 'Age': 7, 'Web': 'www.aideeplearning.cn'}
{'Age': 7, 'Web': 'www.aideeplearning.cn'}
{}
--------------------------------------------------------------------------- NameError Traceback (most recent call last) Cell In[58], line 8 6 print(tinydict) 7 del tinydict # 删除字典 ----> 8 print(tinydict) NameError: name 'tinydict' is not defined
改：通过索引关键字赋值的方式修改键值，代码如下：
tinydict = {'Name': 'VenusAI', 'Age': 7, 'Web': 'www.aideeplearning.cn'}
tinydict['Name'] = 'Venus'
print(tinydict)
{'Name': 'Venus', 'Age': 7, 'Web': 'www.aideeplearning.cn'}
查：通过索引关键字的方法查询键值，注意：如果用字典里没有的键访问数据，会输出错误，代码如下：
#第1章/zidian1.py
tinydict = {'Name': 'VenusAI', 'Age': 7, 'Web': 'www.aideeplearning.cn'}
print ("tinydict['Web']: ", tinydict['Web'])
tinydict['Web']: www.aideeplearning.cn
第一，不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，代码如下：
tinydict = {'Name': 'Venus', 'Age': 7, 'Name': 'VenusAI'}
print ("tinydict['Name']: ", tinydict['Name'])
tinydict['Name']: VenusAI
第二，键必须不可变，所以可以用数字、字符串或元组充当，而用列表就不行，使用列表作为键时输出将会报错，代码如下：
tinydict = {['Name']: 'VenusAI', 'Age': 7}
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Cell In[62], line 1 ----> 1 tinydict = {['Name']: 'VenusAI', 'Age': 7} TypeError: unhashable type: 'list'
集合是一个无序的不重复元素序列。可以使用大括号“{}”或者set()函数创建集合，注意：创建一个空集合必须用set()而不是set{}，因为“{}”是用来创建一个空字典。代码如下：
param = {value01,value02,...}
param = set(value)
由于集合的性质之一是存放不重复的元素，因此可以用于去重功能，代码如下：
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)
{'banana', 'apple', 'pear', 'orange'}
#第1章/jihe.py
a = set('abracadabra')
b = set('alacazam')
# 集合a中包含而集合b中不包含的元素
print(a - b )
# 集合a或b中包含的所有元素
print(a | b)
# 集合a和b中都包含了的元素
print(a & b)
# 不同时包含于a和b的元素
print(a ^ b)
{'b', 'r', 'd'}
{'l', 'r', 'm', 'b', 'z', 'd', 'c', 'a'}
{'c', 'a'}
{'b', 'z', 'l', 'd', 'r', 'm'}
增：将元素x添加到集合s中，如果元素已存在，则不进行任何操作，代码如下：
tinyset = set(("Google", "Baidu", "VenusAI"))
tinyset.add("Facebook")
print(tinyset)
{'VenusAI', 'Google', 'Facebook', 'Baidu'}
还有一个方法，也可以添加元素，且参数可以是列表、元组、字典等，语法格式s.update(x)，其中，x可以有多个，用逗号分开，代码如下：b
tinyset = set(("Google", "Amazon", "Taobao"))
tinyset.update({1,3})
print(tinyset)
{1, 'Google', 3, 'Amazon', 'Taobao'}
删：将元素x从集合s中移除，如果元素不存在，则会发生错误。语法格式s.remove(x)，代码如下：
tinyset = set(("Google", "Baidu", "Amazon"))
tinyset.clear()
print(tinyset)
set()
此外还有一个方法也是移除集合中的元素，并且如果元素不存在，不会发生错误。格式为s.discard(x)。
清空集合的语法格式为s.clear()。
改：集合不支持索引，因此修改元素时一般把集合数据类型转换成列表数据类型。
查：判断元素是否在集合中存在，代码如下：
tinyset = set(("Google", "Baidu", "Amazon"))
print( "Amazon" in tinyset)
print( "FaceBook" in tinyset)
tup=(1,23)
tup=(2,)
True False
（1）可变数据类型：列表、字典、集合。总结这三种数据类型的增删改查方法。
（2）不可变数据类型：元组、数字、字符串。注意，一些初学者可能认为他们可变的原因实际上是这些变量名可以被重新赋值，造成了可变的假象。但是索引这些变量名中的元素是不可被重新赋值的。
（3）下标索引：所谓“下标”，就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间。下标分为正索引和负索引。字符串、列表、元组都支持下标索引，字典则是关键字索引。
（4）切片：切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。切片的语法：[起始:结束:步长]。
注意：选取的区间属于左闭右开型，即从“起始”位开始，到“结束”位的前一位结束（不包含结束位本身），以字符串为例讲解。 如果取出一部分，且间隔取样，则可以在中括号“[]”中，代码如下：
s = "abcdefghi"
print(s[1:7:2])
# bdf
bdf
（5）公共方法，Python包含的内置函数见下表。
