Python基础语法整理

Python基础语法整理

本文章主要讨论Python基础语法中的一下四部分内容：

1.变量类型  2.数据结构  3.循环语句  4.判断语句

目录

1. 变量类型

2. 数据结构

2.1 序列概述

2.2 序列的 *** 作

2.3 列表

2.3.1 函数 list

2.3.2 列表的 *** 作

2.3.3 列表方法

2.4 元组

2.5 字符串

 3. 循环语句

3.1 while循环

3.2 for循坏

3.3 迭代字典

3.4 迭代工具

3.4.1 并行迭代

3.4.2 迭代时获取索引

3.4.3 反向迭代和排序后再迭代

4.条件语句

---

1. 变量类型

2. 数据结构         数据结构是以某种方式（如通过编号）组合起来的数据元素（如数、字符乃至其他数据结构）集合。在Python中， 最基本的数据结构为 序列（ sequence）（包括列表、元组和字符串）。 序列中的每个元素都有编号，即其位置或索引，其中第一个元素的索引为0 ，第二个元素的索引 为1 ，依此类推。 2.1 序列概述         序列是一种数据结构，其中的元素带编号（编号从0 开始）。列表、字符串和元组都属于序列，其中列表是可变的（你可修改其内容），而元组和字符串是不可变的（一旦创建，内容就是固定的）。要访问序列的一部分，可使用切片 *** 作：提供两个指定切片起始和结束位置的索引。要修改列表，可给其元素赋值，也可使用赋值语句给切片赋值。

        重点讨论两种序列：列表和元组。列表和元组的主要不同在于，列表是可以更改的，但元组不可以。也即，列表可以中途添加元素对序列进行修改；而元组出于某种考虑吧需要禁止修改序列。元组作为字典键是不可以用列表代替的，其他情况下均可以用列表代替元组。

2.2 序列的 *** 作 序列 *** 作备注示例索引

01 索引的正负

02 可以直接对序列进项索引 *** 作，可以但是没有必要先赋值给某个变量

03 索引 *** 作不是就地 *** 作，有返回值。

切片

01 访问单个元素       

02 切片访问特定范围内的元素

03 使用两个索引指定切片的边界，并用冒号分隔开来。（其中，第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含再切片内。）

04 如果第一个索引指定的元素位于第二个索引指定的元素后面，结果就为空序列。

05 如果切片始于序列开头（结束于序列末尾），可以省略第二（一）个索引。

06 复制整个序列，则两个索引都省略。

07 切片的第三个参数：步长；

08 步长可以为负数，此时第一个索引指定的元素位于第二个索引指定的元素后面，否则结果为空序列

09 省略起始和结束索引时，步长正负均可以正常迭代。

a[0]

a[0:2]

a[0:]

a[:9]

a[:]

a[0:10:1]

a[0:10:2]

a[10:0:-2]

a[::-1]

a[::1]

序列相加运用加法运算来拼接序列

>>> [1,2,3]+[4,5,6]

[1,2,3,4,5,6]

乘法重复某序列x次以创建一个新序列

>>> 'why'*5

whywhywhywhywhy

>>> [5]*5

[5,5,5,5,5]

成员资格

01 为布尔运算符

02 判断满足条件，返回True，否则返回False

03 可用于检查指定的字符串是否是另外一个字符串的子串。

'x' in a

if a in b (a 和 b 均为字符串)

内置函数长度确定序列的长度

len(a)

最大值找出序列的最大值max(a)最小值找出序列的最小值min(a)

迭代：对序列的每个元素都进行特定的 *** 作。

---

2.3 列表 2.3.1 函数 list

        鉴于不能像修改列表那样修改字符串，可以使用函数 list 将字符串创建为列表，以便修改。

        与 list 相反的 *** 作为 join ，其功能为将字符串列表转换字符串。

2.3.2 列表的 *** 作 *** 作说明示例修改列表：赋值

01 使用索引法给特定（单个）元素赋值

02 不可给不存在的元素赋值

类比切片赋值

删除元素

01 删除所选元素，改变列表长度

del name[2] : 删除 name 的第二个元素给切片赋值

01 替换序列

02 插入序列（不限制数量）

03 同时替换和插入序列

04 插入空切片

01-03 替换还是插入：索引的起始值和终止值之间的索引差值并不一定和将要替换或插入元素的数量相等；

04 : a[3:6] = [ ] 相当于 del a[3:6]  

2.3.3 列表方法

        方法是对象（列表、数、字符串）联系紧密的函数。调用方法：object.method(arguments)

方法说明

示例

append

01 将一个对象附加至末尾（注意该对象层次）

02 就地修改，不会返回新列表

a = [1,2,3]

a.append(4)

结果：a = [1,2,3,4]

clear

01 就地清空列表的内容

02 清空对象不可为列表切片 a[1:2].clear()错误

03 清空后改变列表长度

a.clear() 相当于 a[:] = [ ]copy

01 常规复制：只是将另一个变量名关联到列表

02 copy 为浅拷贝

03浅拷贝中判断拷贝者是否重新指向新的对象

04 就地拷贝，不返回新列表

b = a.copy()

等价于 b = list(a) 或 b = a[ : ], 两者同样为浅拷贝

count 01 非就地计算指定的元素在列表中出现了多少次 02 注意索引深浅 03 返回重复值 a.count(1) / a.count([1,2,3])extend 01 同时将多个值就地附加到列表末尾 02 和 apennd 功能相同 03 就地添加，不返回新列表

a = [1,2,3]

b = [4,5,6]

a.extend(b)

结果 : a =  [1,2,3,4,5,6]

等价于 a + b

等价于 a.extend([4,5,6])

等价于 a[len(a):] = b

index 01 在列表中查找指定值第一次出现的索引 02 有返回值，返回所查找元素的索引 a.index(1) / a.index([1,2]) / a.index('Hello')insert用于将一个对象就地插入列表

a = [1,2,3,5,6,7]

a.insert(3,4)

结果 : a = [1,2,3,4,5,6,7]

pop

01 从列表当中删除一个元素（末尾为最后一个元素）

02 执行后返回被删除的元素

03 pop是唯一既修改列表又返回一个非None值的列表方法

04 pop 可以实现后进先出（LIFO）

05 pop 和 append 的效果相反，将刚d出的的值压入（或附加）之后，得到的栈和原来的相同，也即x.append(x.pop()) 最后输出的结果为 a 其本身

a.pop() : 表示删除列表末尾最后一个

a.pop(1) : 表示删除该列表索引为1的元素

x = [1,2,3]

x.append(x.pop())

输出结果 x = [1,2,3]

remove

01 用于就地删除第一个指定的元素

02 remove就是修改且不返回值的方法之一

03 与 pop 不同的是，它修改列表，但是不返回任何值。而且 remove() 括号中是要删除的元素，而 pop() 括号中是要删除的元素的索引值

a = [1,2,3,4,5,6,7]

a.remove(1) 结果（不返回）

        a = [2,3,4,5,6,7]

a.pop(0) 结果（返回删除的值但不返回a）

        a = [2,3,4,5,6,7]

reserve 01 就地倒序排列列表中的元素 02 不返回任何值

a = [1,2,3]

a.reverse()

结果 a = [3,2,1]

list(reversed(a)) 直接返回 [3,2,1]

03 等价用法 list(reversed(a)) 直接返回倒序的结果，其中reversed(a)返回的是一个迭代器，不是修改后的列表。

sort

01 对列表就地顺序排列：直接对原序列进行修改，不会产生修改后的副本列表

a = [2,4,1,3,5]

a.sort() 不返回 ： a = [1,2,3,4,5]

sorted(a) 直接返回 [1,2,3,4,5]

b = sorted(a) 不返回 ： b = [1,2,3,4,5]

02 sorted(a) 直接返回排列之后的列表，但不修改原列表。和 reversed(a) 不一样；可合法复制 y = sorted(a)，使得 y 可以作为排序之后的副本。

    以上方法中就地 *** 作不可以直接复制给某一个变量，有返回值的可以直接复制给某一个变量。

    sort / reverse 和 sorted / reversed 不同，前两者是方法，后两者是函数。

2.4 元组

（1）与列表一样，元组也是序列，唯一的差别在于元组是不能修改的。

（2）对元组执行的 *** 作：创建和访问：

元组的创建命令执行结果创建不加括号创建>>> 1, 2, 3(1,2,3)加括号创建>>> (1,2,3)(1,2,3)创建空元组>>> ( )( )创建单元素元组>>> 42,(42)

>>> 42

>>> 3*(42,)

42

(42,42,42)

访问元素访问

>>> a[1}

01 元组做映射中的键

02 内置函数和方法返回元组

内置函数：min( )，max( )，len( )...

切片访问>>> a[0:2]

（3）函数tuple的工作原理与 list 很像：它将一个序列作为参数，并将其转换为元组。

---

>>> list([1,2,3])                        [1, 2, 3]
>>> tuple([1,2,3])                     (1, 2, 3)
>>> list('abc')                           ['a', 'b', 'c']
>>> tuple('abc')                        ('a', 'b', 'c')
>>> list((1,2,3))                        [1, 2, 3]
>>> tuple((1,2,3))                     (1, 2, 3)

---

2.5 字符串

（1）不能像修改列表那样修改字符串，可使用函数 list 将字符串创建成为列表。（当然，也有将字符列表转换为字符串的反向 *** 作）

（2）Python 没有专门表示字符的类型，字符串和字符之间的关系：字符串是由字符组成的序列，一个字符就是包含一个元素的字符串。

（3）所有标准字序列 *** 作都适用于字符串，但是字符串是不可改变的，元素赋值和切片赋值均为非法。

（4）字符串格式设置方法          （5）字符串方法 方法说明示例center 通过在两边添加填充字符（默认为空格）让字符串居中 格式：“字符串”.center (整体长度，“填充字符”)

'Hello,world!'. center(39)

"Hello,world!".center(100,"*")

find

01 在字符串中查找子串

02 找到则返回 子串的第一个字符的索引

03 找不到则返回-1 （该方法返回的不是布尔值）

04 可以直接在字符串后面使用，也可以先赋值给变量再使用

05 相比之下，in 只能检查单个字符是否包含在字符串当中

06 在方法 find 中，可以指定搜索的起点和终点

格式： 将搜索的字符串.find("搜索的子串",起点,终点)

subject.find('$$$') subject.find('$$$', 1) subject.find('!!!', 0, 16) join

01 用于合并序列（字符串列表而不能是数字列表）的元素

02 可以直接在字符串后面使用，也可以先赋值给变量再使用

03 作用和 split 相反

格式： ’分隔符（或变量）‘.join( )

分隔符可以是单一元素也可以是字符串，或两者对应的变量，但是不能是字符串列表。

join() 中()内只能是字符串或者包含字符串的单一变量，不能是未赋值给变量的字符串列表本身（only for one argument）

a = ['H','e','l','l','o']

b = "world!"

c = list(b)

d = '+'

以下均为合法 *** 作

'+'.join(a)

d.join(c) == d.join(list(b))

b.join()

lower

01 返回字符串的小写版本

02 有返回值：并非就地 *** 作，意味着可以赋值给某个变量

replace 01 将指定子串都替换为另一个字符串 02 支持多字符替换 03 返回替换后的结果，不影响被替换字符串原序列 04 被替换字符串可以未切片字符串（切片字符串还是字符串） a.replace('b','c')split 01  用于将字符串拆分为序列 02 其作用与 join 相反 03  如果没有指定分隔符，将默认在单个或多个连续的空白字符（空格、制表符、换行符 等）处进行拆分

strip 01 将字符串开头和末尾的空白（但不包括中间的空白）删除并02 返回删除后的结果。 03 可在一个字符串中（只能是开头和结尾）指定删除哪些字符

>>> '*** SPAM * for * everyone!!! ***'.strip(' *!')
'SPAM * for * everyone'
>>> '*** SPAM * for * everyone!!! ***'.strip(' *')
'SPAM * for * everyone!!!'
>>> '*** SPAM * for * everyone!!! ***'.strip('*')
' SPAM * for * everyone!!! '

translate

01 只能进行单字符替换

02 能够同时替换多个字符（参数表中一一对应即可）

03 创建转换表作为 tanslate 的参数

04 支持第三个参数，删除指定字符

>>> table = str.maketrans('cs', 'kz',' ') >>> 'this is an incredible test'. translate (table) 'thizizaninkredibletezt' 其他方法 判断字符串是否满足特定的条件 isalnum 、 isalpha 、 isdecimal 、 isdigit 、 isidentifier 、 islower 、 isnumeric 、 isprintable 、 isspace 、 istitle 、 isupper  3. 循环语句 3.1 while循环

        while(condition) : 条件满足时，即执行 while 循环体。

3.2 for循坏

        可迭代对象是可使用 for 循环进行遍历的对象。迭代（遍历）特定范围内的数是一种常见的任务，Python提供了一种创建范围的内置函数。以下是一些例子。

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]             # 打印出数字列表中的数字 for number in numbers: print(number)         words = ['this', 'is', 'an', 'ex', 'parrot']                # 打印出字符串列表中字符串 for word in words: print(word) >>>range(10)                                                  #如果只提供了一个位置，将把这个位置视为结 range(0,10)                                                      束位置，并假定起始位置为0                                                                       >>> list(range(0, 10))                                      # 列出1~10之间的数（包含0不包含10） [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] for number in range(1,101):                            # 打印1~100之间的数 print(number) 3.3 迭代字典

        遍历字典中所有的关键字，可像遍历序列那样使用普通的 for 语句。

     也可以用以下方法 ：  d.items 以元组的方式返回键- 值对。

                字典元素的排列顺序是不确定的。换而言之，迭代字典的键或值时，一定会处理所有的 键或值，但不知道处理的顺序。如果顺序很重要，可将键或值存储在一个列表中并对列 表排序，再进行迭代。要 3.4 迭代工具 3.4.1 并行迭代 （1）同时迭代两个序列，一般我们可以这样做：

names = ['anne','beth','george','damon']
ages = [12,45,32,102]
for i in range(len(names)):
    print(names[i],'is',ages[i],'years old')
运行结果：
anne is 12 years old
beth is 45 years old
george is 32 years old
damon is 102 years old

 （2）使用并行迭代工具：内置函数 zip 实现上述功能。zip 的功能是将两个序列缝合起来，并返回一个由元组组成的序列。

names = ['anne','beth','george','damon']
ages = [12,45,32,102]
# list(zip(names,ages))
for name, age in zip(names, ages):
    print(name,'is',age,'years old')
运行结果
anne is 12 years old
beth is 45 years old
george is 32 years old
damon is 102 years old

（3）函数zip可用于“缝合”任意数量的序列。需要指出的是，当序列的长度不同时，函数zip将在最短的序列用完后停止“缝合”。

b = list(zip(range(5), range(100000000)))
print(b)
运行结果：
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

3.4.2 迭代时获取索引 3.4.3 反向迭代和排序后再迭代

reversed 和 sorted 函数，不就地修改对象，有返回值。

 对于排序后再迭代函数 sorted 来说，如果要按字母进行排序（不区分大小写），则先进行小写转换。为此，可将 sort 或 sorted 的关键字 key 参数设置为 str.lower。如下例子所示。

y = sorted('AsfGKlITdmxpWmR',key=str.lower)
print(y)
运行结果
['A', 'd', 'f', 'G', 'I', 'K', 'l', 'm', 'm', 'p', 'R', 's', 'T', 'W', 'x']

4.条件语句 （1）用作布尔表达式时，下面的值都将被解释器视为假 ： False  None  0 ""  ()  []  {}。换而言之，标准值False和None、各种类型（包括浮点数、复数等）的数值0、空序列（如空 字符串、空元组和空列表）以及空映射（如空字典）都被视为假，而其他各种值都被视为真 ， 包括特殊值True 。

（2）布尔值True和False属于类型bool，而bool与list、str和tuple一样，可用来转换其他的值。

（3）条件语句

条件语句说明示例if条件为真时执行相应模块的语句 num = int(input('Enter a number: ')) if num > 0:         print('The number is positive') elif num < 0:         print('The number is negative') else:         print('The number is zero') elseelif （3）条件语句的嵌套：注意嵌套层次 （4）比较运算符：Python支持 链式比较（比如  1 <= number <= 10） （5）相等运算符 和 相同运算符 做条件         核心一点：==用来检查两个对象是否相等，而is用来检查两个对象是否相同（是同一个对象）。 （6）字符串和序列的比较         字符串是根据字符的字母排列顺序进行比较的。