关于python:Python基础语法和数据类型最全总结

摘要：总结了 Python 最全根底语法和数据类型总结，一文带你学会 Python。

本文分享自华为云社区《Python 最全根底语法和数据类型总结》，原文作者：北山啦。

人生苦短，我用 Python。总结了 Python 最全根底语法和数据类型总结，一文带你学会 Python。

Python 最全根底总结

1. 编写第一个程序
2. Python 中的正文
3. Python 代码根本架构
4. 数据类型
5. 运算符
6. 内置函数
7. 字符串类型
8. 应用 % 占位符格式化字符串
9. 应用 format()函数格式化字符串
10. 应用 f -string 来格式化字符串
11. 字符串操作
12. list 和 tuple
    list
    list 操作函数
13. tuple
14. 字典类型
    字典类型操作方法
15. 汇合类型
    汇合操作
    汇合运算

编写第一个程序

哈哈，入门语言，当然第一句话就是 hello world，相比于 C 和 Java，Python 的语法格局非常简单，间接 print()即可

上面咱们开始写第一个程序：输入 Hello World!

它会输入一个字符串”Hello World!“。
如果屡次调用 print()函数，如下：

能够看到，每条 print()语句，都会占一行。如果想将下面的三句话输入到同一行，能够这样：

通过给 print 加上 end=””，将 print()函数原来默认的输入内容后加上换行，改成了输入内容后加上空字符串，这样就不会换行了。另外，print()中除了能够接管字符串参数外，也能够接管其余任何参数，还能够调用函数，将函数执行后果打印进去。还能够是一个表达式，将表达式的运行后果打印进去。

Python 中的正文

在上一端代码中，咱们在 print()语句后，应用 #给代码退出了正文。这是很罕用的一种正文形式：单行正文。
如果有多行的正文，能够应用三对双引号或者单引号将其包裹起来：

除了下面两种正文外，还有一种特地的正文，那就是文档正文。文档正文次要是用于主动生成帮忙文档，它对于格局和地位有肯定要求。

如果你的程序可能会被其他人用到，为了不便他们，防止它们查看你的代码来取得试用办法，应该提供文档正文，并生成文档提供给他们。

文档正文必须是包、类或函数里的第一个语句。这些字符串能够通过对象的 doc 成员被主动提取，并且能够被 pydoc 应用。而且文档正文必须应用三对单引号或者双引号来正文，不能应用 #

为了更好更清晰地阐明函数的作用，函数的文档应该遵循肯定的规定：

• Args：列出每个参数的名字，并在名字后应用一个冒号和一个空格，分隔对该参数的名称和形容。如果形容太长超过了单行 80 字符，应用 2 或者 4 个空格的悬挂缩进
• Returns：该函数的返回值，包含类型和具体返回值的状况。如果没有返回值或者返回 None 值能够不写
• Raises：抛出的异样。不抛出异样不写。
  

Python 代码根本架构

在后面的几个程序中，咱们根本能领会到 Python 程序的一些特点。

首先，Python 代码中，不应用 {} 或者其余显著的标记来限度代码的开始和完结，而是依据代码的缩进来确定代码的关系：间断的同一缩进的代码为同一个代码块，例如函数中的定义。
一条语句的开端，不须要应用; 来完结，而间接应用换行示意语句开端。

除此外，Python 还有一些颇具特色的写法，例如，如果一条语句太长，能够应用”\“将它宰割成多行：

尽管 Python 中能够不应用; 作为语句的宰割，但如果在一行中有多条语句，那能够应用; 将这些语句分隔开：

数据类型

在下面这些代码中，咱们定义了变量 a、b、x、y 等。能够看出，在 Python 中，和很多其余编程语言不一样的中央，Python 的变量不须要申明为具体的类型，而是间接给它赋值，Python 会依据值设置变量的类型。尽管 Python 的变量不须要先申明类型间接就能够应用，但并不是说 Python 没有数据类型。Python 的罕用数据类型包含：

• number（数字）
• int（整型）
• float（浮点型）
• complex（复数）：复数由实数局部和虚数局部形成，能够用 a + bj, 或者 complex(a,b) 示意，复数的实部 a 和虚部 b 都是浮点型
• bool
• string（字符串）
• list（列表）
• tuple（元组）
• set（汇合）
• dict（字典）
  这些类型，咱们在后续课程将会一一讲到。

运算符

在 Python 中，提供了罕用的运算符。咱们先来看看它的数学运算符。

• /
• %：取余
• //：整除
• **：乘方
  
  

能够看到，整数和浮点数的运算，后果都是浮点数。如果想将浮点数转换成整数，能够这样：

或者将整数转换成浮点数：

bool 类型只有两个值：True 或者 False。它的运算操作有 not、and、or

内置函数

所谓内置函数，就是 Python 语言自身曾经定义好的给咱们能够间接应用的函数，例如后面用到的 print()、abs()、int()、float()等。这些函数前面咱们都会在适当的中央讲到。

后面咱们讲了 print()，咱们来看看输出。

输出应用 input()，它接管一个字符串作为显示给用户的提示信息，用户输出后，将会以字符串模式返回给程序。

字符串类型

字符串是最罕用的数据类型之一，它用来示意一串不可变的字符。
字符串能够应用双引号或者单引号将字符蕴含起来

• 如果字符串中原本就含有单引号或者双引号，能够通过上面的办法来解决：
  
• 如果字符串中蕴含单引号，则应用双引号来包裹这个字符串，反之，如果字符串中蕴含双引号，则应用单引号来包裹这个字符串，例如：
  

如果字符串中即有单引号又有双引号，则能够对字符串内的单双引号进行本义，即在字符串内的单双引号后面加上 \，例如：

中文的全角单双引号不受影响，即中文单双引号会被当做一般字符。对于内容简单的字符串，也能够应用 ”””””” 或者’’’’’’ 来包裹字符串，此时无论外面有单引号还是双引号，均会被一成不变地正确处理。

应用 % 占位符格式化字符串

有时候，咱们可能须要在字符串中退出一些不确定的内容，例如，依据用户的输出，输入语句问候语：

这种形式能够实现咱们的目标，但它在可读性和性能上都不够优化。所以在 Python 中陆续提供了三种格式化字符串的形式。咱们先来看第一种：应用占位符 %。如果将下面的代码改成应用 % 占位符，它能够批改成如下：

这种形式的益处是，% 占位符能够主动将非字符串类型的数据转换成字符串，并和字符串其余局部相连接，造成新的字符串。
它的规范格局是：%(name)[width].[precision]typecode

除了 f、s、d 外的其余格局字符，请见上面例子：

指定 name 的形式：

这种格式化数据缓缓被抛弃了，因为它的占位符和值之间必须一一对应，在占位符比拟多的时候，比拟容易出错。

应用 format()函数格式化字符串

着这种形式下，应用 {} 作为占位符，但它的益处在于能够给它指定程序，例如：

还能够退出变量：

思考上面这种状况：A 喜爱 B，可 B 不喜爱 A
如果 A、B 待定，用后面的格式化形式定义如下：”%s 喜爱 %s，可 %s 不喜爱 %s”%(“A”,“B”,“B”,“A”)
这种形式的问题在于：

1. 都用 %s 来指定，看不出 A、B 的区别
2. A、B 其实各反复了一次，如果反复屡次，须要反复写更屡次。
   如果用 format()函数，能够写成：
   

当然，在 format()中也能够应用相似 % 一样的数据类型等设置：

指定长度和精度：

另外，在指定了长度之后，如果对应的值有余，能够指定补足的字符（默认是空格，例如下面北山啦前面的空格），此时必须配合对齐形式来应用：

• “<”：左对齐
• “^”：居中对齐
• “>”：右对齐
  

应用 f -string 来格式化字符串

format()办法相比拟 % 来说曾经有显著的改良，但在某些简单状况下，还是显得不够灵便。例如：

能够看到，一旦参数比拟多，在应用 format()的时候，须要做比拟多的无用功。其实如果能间接在 {} 中，和变量间接一一对应，那就不便很多了。能够应用 f -string 改成

因为 f -string 的 {} 中的内容，会在运行时进行运算，因而在 {} 中也能够间接调用函数、应用表达式，例如：

对于多行文字，为了让代码更好看易读，应该写成如下形式：

当然，在 f -string 中也能够应用下面的各种限度：

再如：

指定对齐形式：

不同进制、不同示意形式的数字：

字符串操作

如果要从字符串中取得其中的一段子字符串，能够通过 str[start:end]的办法来取得。其中 start 为开始索引，end 为完结索引，但 end 对应索引的字符不蕴含在内。如果只取单个字符，则只须要指定 start 参数就能够了。

咱们常常须要对字符串进行操作，所以 Python 提供了很多字符串操作的函数供咱们应用。

• capitalize()：字符串首字母大写
• title()：将字符串中各个单词的首字母大写
• lstrip()、rstrip()、strip()：别离用于去除字符串右边、左边和左右两边的空格
• 须要留神的是，下面这些办法，都不会扭转原有字符串内容，而是新生成字符串
• startswith(prefix, start, end)：该字符串是否以某个字符串开始
• endswith(suffix, start, end)：该字符串是否已某个字符串结尾
• find(s, start, end)：从字符串中从左到右寻找是否蕴含字符串 s，返回找到的第一个地位。如果没找到，返回 -1
• rfind(s, start, end)：和 find()相似，只不过它从右到左寻找
• index(s, start, end)：和 find()相似，但如果没找到将会返回谬误
• rindex(s, start, end)：和 index()相似，只不过它从右到左寻找
• isalnum()：如果字符串中至多有一个字符，且字符串由数字和字母组成，则为 true。
• isalpha()：如果字符串中至多有一个字符，且字符串由字母组成，则为 true
• isdigit()：是否为数字（整数），小数点不算，只反对阿拉伯数字
• isnumeric()：是否为数字。反对本地语言下的数字，例如中文“一千三百”、“壹万捌仟”等
• replace(s1, s2)：将字符串中的 s1 替换成 s2
  

上面咱们看一个综合案例。

指定字符串中，将字符串中和第一个字母一样的字母（除第一个字符自身外），都替换成另一个字符“@”，例如：little，替换后成为 litt@e，行将 little 中所有的 l(第一个字母是 l）都替换成 @（除了第一个字母自身），上面是一种实现思路：

list 和 tuple

应用列表 list 或者元组 tuple，能够寄存一系列的数据，例如，将班级所有同学的名字放在一起：
names = [“北山啦”,“李四”,“王五”]

list

list 是一种有序的、可变的数据汇合，可变的意思就是能够随时往里增加或者删除元素。
能够通过索引从中取出元素，例如 names[1]将取出第二个数据（索引从 0 开始）。

• 如果索引超出范围（例如索引大于等于列表个数），将会报错
• 索引能够是正数，正数示意从后往前计数取数据，最初一个元素的索引此时为 -1
  

列表中的元素，其数据类型不肯定要一样。甚至能够应用列表数据作为另一个列表的元素。如：
names = [“北山啦”,“李四”, [“Leonardo”,“Dicaprio”],“王五”]，其中，第三个元素（索引为 2）为另一个列表

此时，names[2]取出来的值是列表 [“Leonardo”,“Dicaprio”]，要取 Leonardo 这个值，则须要在这个列表[“Leonardo”,“Dicaprio”] 上应用索引 0 去获取，因而，能够通过 names2 获得

如果要从列表中取出肯定范畴内的元素，则能够应用 list[start:end]的形式来获取，例如：names[1:3]取出从索引 1 开始到索引 3 完结（不蕴含索引 3）的 2 个元素。

• start 如果省略，示意从 0 开始
• end 如果省略，示意到列表最初一个元素完结
  

如果要创立一系列数字为内容的列表，能够联合 list()函数和 range()函数来创立，例如，创立蕴含数字 0 -99 的列表：

print(list(range(100)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
range(0, 100)

range()的函数原型：

• range(stop)：0 开始计数，计数到 stop 完结，但不包含 stop，例如：range(10)，生成的数字范畴是 0 -9
• range(start, stop[, step])：计数从 start 开始，到 stop 完结（不包含 stop），step 是步长，即每次变动的范畴，默认为 1，即每次加 1
• start/stop/step 均能够为任意整数
• “start < stop”，能力生成蕴含元素的 range，如果 stop< start，则为空。
  

list 操作函数

• append(element)：往列表最初附加一个元素
• insert(index, element)：往列表指定索引地位插入一个元素
• 能够间接给指定索引元素赋值，用新值代替旧值：names[idx]= value
• pop()将最初一个元素从列表中取出来，并从列表中删除该元素
• 如果要删除列表中的一个索引对应的元素，能够应用 del list[idx]的形式
• extend(seq)：在原来的列表后追加一个系列
• remove(obj)：从列表中删除第一个匹配 obj 的元素
• clear()：清空整个列表
• count(obj)：计算元素 obj 在列表中呈现次数
• sort(key=…, reverse=…)：给 list 排序，能够指定用于排序的 key。reverse 用于指定是否反序。
  

[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 0, -5, -10, -15, -20, -25, -30, -35, -40, -45, -50, -55, -60, -65, -70, -75, -80, -85, -90, -95]

上面咱们来看一个更简单的列表：

the_irishman = [[“Robert”,“De Niro”], [“Al”,“Pacino”],
[“Joe”,“Pesci”], [“Harvey”,“Keitel”], [“Bobby”,“Cannavale”]]

假如咱们当初要给它进行排序，那么应该是依照 first name 还是 last name 来排序呢？
此时就须要用到 sort()函数中的 key 参数了。通过 key 能够给它指定一个函数，这个函数来限度应该依照 first name 还是 last name 来排序：

tuple

tuple 和列表相似，它们的区别在于 tuple 是不可变的，即如果元组初始化了，则不能扭转，tuple 没有 pop()/insert()这些办法。
须要留神的是，这里的不可变，指的是不能间接将 tuple 元素扭转成另一个元素，但如果 tuple 的元素是一个可变对象，例如 list，那么，list 外面的内容是能够扭转的，但不能用另一个 list 去替换 tuple 中既有的 list。

元组还有一个须要特地留神的中央是只有一个元素的元组数据的定义。因为 () 还是表达式中应用的符号（用来扭转操作符程序），因而如果只有一个元素，定义成 names = (“北山啦”)，此时 () 会被当做表达式符号，这里就会被疏忽掉，因而 names 的值此时为字符串”北山啦”，而不是元组类型。为防止这种状况，能够这样定义单个元素的元组数据：names = (“北山啦”,)

另外还能够应用上面的办法创立元组：

列表和元组均能够乘以一个整数 n，示意将原来列表或者元组中的数据复制 n 份生成新列表或者元组:

列表和列表之间、元组和元组之间，能够应用“+”将两个列表或者元组中的数据合并成新的列表或者元组

留神，tuple 和 list 是不能合并的。

如果想一一取出列表或者元组中的元素，能够通过 for…in…的形式一一取出元素：

字典类型

字典（dict）是用于保留键 - 值（key-value）对的可变容器数据。

字典的每个键值 (key-value) 对用冒号 (:) 宰割，每个键值对之间用逗号 (,) 宰割，整个字典包含在花括号 ({}) 中 , 格局如下所示：

• d = {key1 : value1, key2 : value2}
• 留神，字典中的 key 必须惟一，即不能有两对 key 一样的元素。
• 能够通过 d[key]的形式，取得对应 key 的 value。如果不存在对应的 key，则会报错。
  

{'Phoenix': 'Suns', 'Atlanta': 'Hawks', 'Boston': 'Celtics', 'Chicago': 'Bulls', 'Denver': 'Nuggets', 'Detroit': 'Pistons', 'Los Angels': 'Clippers'}
Suns

• 给字典减少数据，能够通过
• d[new_key] = new_value
• 批改某个 key 对应的值
• -d[key] = new_value
• 删除某个 key 对应的元素
• del d[key]，将会删除 key 对应的键值对，不仅仅是删除值
• del d，将会删除整个字典数据
  

{'Phoenix': 'Suns', 'Atlanta': 'Hawks', 'Boston': 'Celtics', 'Chicago': 'Bulls', 'Denver': 'Nuggets', 'Detroit': 'Pistons', 'Los Angels': 'Lakers', 'Orando': 'Magics'}

为了防止 key 的不惟一，要求 key 只能应用不变的数据做 key，例如：数字、字符串、元组。list 因为是可变数据，所以不能当做 key。

字典类型操作方法

• items()：以列表返回可遍历的(键, 值) 元组数组
• keys()：返回一个蕴含所有键的可迭代对象，能够应用 list() 来转换为列表
• values()：返回一个蕴含所有值的可迭代对象，能够应用 list() 来转换为列表
• pop(key[,default])：取出对应 key 的值，如果不存在，则应用 default 值
• popitem()：取出字典中最初一个 key-value 对
• get(key[,default])：取出对应 key 的值，如果不存在这个 key，则应用 default 值
  

dict_keys(['Phoenix', 'Atlanta', 'Boston', 'Chicago', 'Denver', 'Detroit', 'Los Angels'])
dict_values(['Suns', 'Hawks', 'Celtics', 'Bulls', 'Nuggets', 'Pistons', 'Clippers'])
dict_items([('Phoenix', 'Suns'), ('Atlanta', 'Hawks'), ('Boston', 'Celtics'), ('Chicago', 'Bulls'), ('Denver', 'Nuggets'), ('Detroit', 'Pistons'), ('Los Angels', 'Clippers')])
Suns
Hawks
Celtics
Bulls
Nuggets
Pistons
Clippers

Nuggets
{'Phoenix': 'Suns', 'Atlanta': 'Hawks', 'Boston': 'Celtics', 'Chicago': 'Bulls', 'Detroit': 'Pistons', 'Los Angels': 'Clippers'}
('Los Angels', 'Clippers')
{'Phoenix': 'Suns', 'Atlanta': 'Hawks', 'Boston': 'Celtics', 'Chicago': 'Bulls', 'Detroit': 'Pistons'}
Suns

汇合类型

汇合（set）是一个无序的不反复元素序列。能够应用 set()或者 {} 来创立一个汇合：

• 如果应用 {} 创立汇合，要留神和字典数据类型的区别——字典数据里是 key-value 对，而这里是单个的数据
• 如果创立空集合，不能够应用 {}，因为零碎会首先将其当做字典数据类型来解决。所以空集合请应用 set() 来创立
• 如果往汇合中放入反复元素，将只会保留一个。
  从字符串创立一个汇合：
  

从列表创立一个汇合：

从元组创立一个汇合：

从字典创立一个汇合，此时只会取 key 作为汇合的元素：

汇合操作

• add()：往 set 中减少一个元素，如果该元素曾经在 set 中，则不会胜利。参数只能是单个元素，不能使 list、tuple 或者 set

• update(seq)：往 set 中增加多个元素。seq 能够是字符串、tuple、list 或者另一个 set
• 须要留神：add()和 update()都是字符串作为参数的时候，两者的区别：add()把字符串当做一个整体退出，而 update()会将字符串中的单个字符一一退出
• discard(item)：从汇合中删除指定的元素。
• remove(item)：从汇合中删除指定的元素。如果该元素不存在，会报错。
• pop()：从汇合中移除一个元素。因为汇合是无序的，所以不能确保移除的是哪一个元素
• clear()：清空整个汇合
  

汇合运算

汇合之间，能够进行汇合操作，次要的汇合操作有：

• 交加（intersection）：两个汇合操作，生成一个新的汇合：只有两个汇合中都有的元素，才会被放到新的汇合中
• 能够应用运算符 & 或者函数 intersection()来进行交加操作
• 并集（Union）：两个汇合生成一个新的汇合，两个汇合中的元素都会放到新的汇合中
• 能够应用 | 操作符或者 union()函数进行并集操作
• 差集（difference）：两个汇合生成新的汇合，在原汇合根底上，减去两者都有的元素，生成新的汇合。
• 能够应用 - 操作符或者 difference()函数来进行差集操作
• 对称差集（symmetric difference）：两个汇合生成新的汇合，新汇合中的元素是两个汇合的元素减去两者一样的元素。
• 能够应用 ^ 操作符或者 symmetric_difference()函数进行对称差集操作
  

其余操作：

• symmetric_difference_update()/ intersection_update()/ difference_update()/update()：还是进行后面的对应交、并、差、对称差操作，但将运算的后果，更新到这个汇合。
• isdisjoint()：a.isdisjoint(b)，a 和 b 两个汇合是否没有交加，没有交加返回 True
• issubset()：a.issubset(b)，a 是否为 b 的子集，是返回 True
• issuperset()：a.issuperset(b)，a 是否为蕴含 b 的所有元素，蕴含返回 True
  
  

点击关注，第一工夫理解华为云陈腐技术~