关于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
  
  

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