掌握Python基本语法的终极指南【基本语法部分】

一、基本语法部分

1.简单数据类型

1.1字符串类型及操作

字符串访问：

1.索引访问

mystr="Hello world"
#索引访问
print(mystr[0])  #H
print(mystr[-1]) #d
print(mystr[-7]) #o
print(mystr[6])  #w

2.切片访问

[头下标：尾下标] ，这种访问方式称之为"切片"。

但注意这是左闭右开的区间。

在切片方式中，若头下标缺省，表示从字符串的开始取子串；

若尾下标缺省，表示取到字符串的最后一个字符；

若头下标和尾下标都缺省，则取整个字符串。

#切片访问
print(mystr[0:5])
print(mystr[:10])
print(mystr[0:])
print(mystr[6:-1])
print(mystr[:])
'''
Hello
Hello worl
Hello world
worl
Hello world
'''

还可以设置取子字符串的顺序，格式为【头下标：尾下标：步长】。

当步长大于0的时候，从左往右取字符；当步长小于0的时候，从右往左取字符。

print(mystr[0:8:1])
print(mystr[-1:5:-1])
print(mystr[0:8:2])
print(mystr[-9:-1:1])
'''
Hello wo
dlrow
Hlow
llo worl
'''

字符串处理函数:

len(x)返回字符串长度

str(x)返回任意类型x对应的字符串形式

length=len("hello world")
print(length)  #11
string=str(134)
print(type(string),string) #<class 'str'> 134

字符串方法

1.字符串查询（index,find)

建议使用find,若未找到匹配的字符串，index方法报异常

find(str,beg=0,end=len(string))

查找子串s第一次出现的位置，如果找到则返回相应的索引，否则返回-1

str1="my name is five.what's your name?"
str2="name"
print(str1.find(str2)) #5
print(str1.find(str2,5)) #28
print(str1.find(str2,35)) #-1

2.字符串大小写转换操作（upper、lower、swapcase、capitalize和title)

|------------|---------------------|
| 方法名称 | 功能 |
| upper | 将字符串中所有元素都转为大写 |
| lower | 将字符串中所有元素都转为小写 |
| swapcase | 交换大小写。大写转为小写，小写转为大写 |
| capitalize | 第一个大写，其余小写 |
| title | 每个单词的第一次字符大写，其余均为小写 |

print(str2.upper()) #NAME
print(str2.lower()) #name
print(str2.title()) #Name

3.分割字符串（split,splitlines,partition)

|------------------------------------|---------------------------------------------------------------------|
| 方法名称 | 功能 |
| split(seq=",num=string.count(str)) | 以seq(默认空格)为分隔符截取字符串，如果num有指定值，则仅截取num+1个子字符串（只需num个seq分隔符）。分割后得到新列表 |
| rsplit | 与split类似，不过是从右边开始分割 |
| splitlines | 按照行进行分割，得到新的列表 |
| partition(str) | 找到字符串中第一个str,并以str为界，将字符串分割为3部分，返回一个新的元组 |
| rpartition(str) | 与partition类似，只不过是反向找 |

#str1="my name is five.what's your name?"
print(str1.split()) #以空格为分割符
print(str1.split('i',1)) #以i为分割符
print(str1.split('b')) #以b为分割符
print(str1.partition("name")) #以name为分割符
print(str1.rpartition("name")) #以name为分割符，从右往左找
str="""my name is Alice
    what is Bob's name?"""
print(str.splitlines()) #以换行符为分割符

4.合并与替换（join,replace)

|--------------------------|------------------------------------------|
| 方法名称 | 功能 |
| join(seq) | 以指定字符串作为分隔符，将seq中所有的元素（的字符串表示）合并为一个新的字符串 |
| replace(old,new[,max]) | 把将字符串中的old替换成new,如果max指定，则替换不超过max次 |

5.字符串计数（count,len)

|------------------------------------|----------------------------------|
| 方法名称 | 功能 |
| count(sub,start=0,end=len(string)) | 在字符串[start,end)范围内，计算sub字符串的个数 |
| len | len不是string的方法，是内置函数，计算字符串中的字符个数 |

6.去除两端多余字符操作（strip)

|-------------|---------------------------|
| 方法名称 | 功能 |
| Istrip(str) | 去掉左边的str字符（不是字符串），默认为空白字符 |
| rstrip(str) | 去掉右边的str字符 |
| strip(str) | 去掉左右两边的str字符 |

1.2输入和输出函数

输入：input()函数

作用：从控制台获取用户的输入，以字符串类型返回结果

获得用户输入之前，input()函数可以包含一些提示性文字 <变量> = input(<提示性文字>)

a=input("请输入一个数：")
b=input("请输入一个数：")
print(a+b)
print(int(a)+int(b))
'''
请输入一个数：12
请输入一个数：34
1234
46
'''

输出函数：print()函数

该函数可以同时输出多个参数并使用分隔符分隔。

print()函数可以输出各种类型变量的值

格式化字符串方法：

1） print()函数通过%来选择要输出的变量类型---最早引入一种方法

格式化字符串中变化的部分使用占位符

变量以元组形式提供

变量与格式化字符串之间以%连接

格式的字符串（即%s）与被格式化的字符串（即传入的值）必须按照位置一一对应，

缺点：当需格式化的字符串过多时，位置极容易搞混

2）str.format 内建函数

该format函数是在python2.6以后引入的，是字符类型的内置方法。因为str.format的方式比%在性能和灵活性上更好一些。

1.使用位置参数：按照位置一一对应

first_name='bruce'
last_name='wu'
message="Hello {} {}.".format(first_name,last_name)
print(message)#Hello bruce wu.

2.按照索引匹配对应的值

first_name='bruce'
last_name='wu'
message="Hello {1} {0}.".format(first_name,last_name)
print(message)#Hello wu bruce.

3.按照关键字指定对应的值

print('我来自{place},我的年龄是{age}。'.format(place='中国',age=18))
#我来自中国,我的年龄是18。

3）f-String

由python3.6版本引入的一个特性，称之为字面量格式化字符串

以F或者f开头，后面跟字符串，字符串中的表达式用大括号{ }包起来，

它会将变量或表达式计算后的值替换进去

first_name='bruce'
last_name='wu'
message=f"Hello {last_name} {first_name}."
print(message)#Hello wu bruce.

eval（）函数

它能够以Python表达式的方式解析并执行字符串， 将返回结果输出

1、计算字符串中有效的表达式，并返回结果

print('5+2')
print(eval('5+2'))
print(eval('pow(2,2)'))
x=5
print(eval('x+2'))
'''5+2
7
4
7'''

2、将字符串转成相应的对象（如list、tuple、dict和string之间的转换）

1.3 数：整数和浮点数

可在数中添加下划线使大数更易读

基本算术运算：

除（/）：任意两个数相除时，结果总是浮点数

双斜杠（//）：表示整数除法，取两数的整数商

双乘号（**）：表示乘方运算

求模运算（%） ，计算取整除法的余数

注：浮点数计算时，结果包含的小数位数可能是不确定的。

保留浮点数小数位数的几种常见方法：

1.使用round（）函数

2.使用字符串格式化

3.使用字符串的f-string格式化

4. 使用format（）函数

5.使用decimal模块

number=3.1415926
round_number=round(number,2)
print(round_number)
format_number='{:.2f}'.format(number)
print(format_number) #3.14
f_string_number=f'{number:.2f}'
print(f_string_number) #3.14
format_fun_number=format(number,'.2f')
print(format_fun_number) #3.14
from decimal import *
decimal_number=Decimal(number)
decimal_number1=decimal_number.quantize(Decimal('0.00'),rounding=ROUND_HALF_UP)
print(decimal_number) #3.1415926
print(decimal_number1) #3.14

round( ) 函数

round(a, b) 函数

返回浮点数 a 小数点后 b 位的四舍五入值，当 b 省略时 a 取整。

内置的数字运算函数

|------------------|---------------------|
| 函数 | 描述 |
| abs(x) | 绝对值 |
| divmod(x,y) | (x//y,x%y),输出为二元组形式 |
| pow(x,y[,z]) | (x**y)%z |
| round(x[,n]) | 四舍五入，保留n位小数 |
| max(a,b,Z.....) | 求最大值 |
| min(a,b,Z......) | 求最小值 |

内置的数字类型的转换函数

int(x)==>把x转换成整数，x可以是浮点数、字符串、整数、分数

float(x)==>返回浮点数或字符串所对应的整数类型

complex（re [,im])==>生成一个复数，re+im j，re可以是整数、浮点数、字符串，im不能是字符串。

Math库

导入方法： import math from math import * #*表示函数名

math.fabs(x) ：返回x的绝对值

math.fsum([x,y...]):浮点数精确求和

math.cell(x):向上取整

math.floor(x)：向下取整

math.pow(x,y):返回x的y次幂

math.sqrt(x)：返回x的平方根

1.4 Python运算符与表达式

*运算符除了表示算术乘法，还可用于列表、元组、字符串这几个序列类型与整数的乘法，表示序列元素的重复，生成新的序列对象。

字典和集合不支持与整数的相乘，因为其中的元素是不允许重复的。

成员测试运算符in用于成员测试，即测试一个对象是否为另一个对象的元素。

同一性测试运算符is用来测试两个对象是否是同一个，如果是则返回True，否则返回False。

如果两个对象是同一个，二者具有相同的内存地址。

2.Python可迭代对象

2.1、List（列表）

在形式上，列表的所有元素放在一对方括号[]中，

相邻元素之间使用逗号分隔，元素之间可以没有任何关系。

可以使用list(可迭代对象)函数把

元组、range对象、字符串、字典、集合或其他有限长度的可迭代对象转换为列表。

当一个变量不再使用时，可以使用del命令将其删除，这一点适用于所有类型的变量

创建列表之后，可以使用整数作为下标来访问其中的元素，其中0表示第1个元素，1表示第2个元素，2表示第3个元素，以此类推；列表还支持使用负整数作为下标，其中-1表示最后1个元素，-2表示倒数第2个元素，-3表示倒数第3个元素，以此类推

（1）添加元素：append()、insert()、extend()

append(val)用于向列表尾部追加一个元素，

insert(index,val)用于向列表任意指定位置插入一个元素，

extend(iterable)用于将参数可迭代对象中的所有元素追加至当前列表的尾部，对当前列表元素进行批量增加

这3个方法都属于原地操作，不影响列表对象在内存中的起始地址。

x=[1,2,3]
x.append(4)
x.insert(0,0)
x.extend([5,6,7])
print(x) #[0, 1, 2, 3, 4, 5, 6, 7]

（2）删除元素：pop()、remove()、clear()

pop(index): 用于删除并返回指定位置（默认是最后一个）上的元素；

remove(value): 用于删除列表中第一个值与指定值相等的元素；

clear(): 用于清空列表中的所有元素。

del : 删除列表中指定位置的元素

这4个方法也属于原地操作。

x=[1,2,3,4,5,6,7]
x.pop()#弹出最后一个元素
x.pop(0) #弹出第一个元素
x.clear()
print(x) #[]
x=[1,2,1,1,2]
x.remove(2) #删除第一个2
del x[3]
print(x) #[1, 1, 1]

（3）统计元素：count()、index()

count()用于返回列表中指定元素出现的次数；

index()用于返回指定元素在列表中首次出现的位置，如果该元素不在列表中则抛出异常。

（4）排序和反转：sort()、reverse()

lst.sort() ：永久修改原列表，对其中的元素进行排序。

sorted(lst) -> lst'：返回排序后的列表的副本。 原列表不变

reverse()：永久修改原列表，对其中的元素进行翻转

（5）获取列表的长度： len() 函数

len(lst) -> num：获取列表的元素个数。

（6）copy()方法

copy()方法返回当前列表的浅复制，返回包含原列表中所有元素的引用的新列表。

标准库copy中的deepcopy()函数可以实现深复制，对原列表中的元素的引用进行复制，

如果元素是容器对象就递归对其中的元素进行复制。深复制得到的对象与原来的对象完全独立。

把同一个列表赋值给两个变量时，这两个变量的引用不同，得到两个不同的列表，

但有可能两个列表中的元素具有相同的引用。

直接把一个变量赋值给另一个变量时，两个变量引用同一个对象（=）

内置函数对列表的操作

max()、min()函数用于返回列表中所有元素的最大值和最小值

sum()函数用于返回列表中所有元素之和

len()函数用于返回列表中元素个数

zip()函数用于将多个列表中元素重新组合为元组并返回包含这些元组的zip对象

enumerate()函数返回包含若干下标和值的迭代对象

map()函数把函数映射到列表上的每个元素

filter()函数根据指定函数的返回值对列表元素进行过滤

all()函数用来测试列表中是否所有元素都等价于True

any()用来测试列表中是否有等价于True的元素

标准库functools中的reduce()函数以及标准库itertools中的compress()、groupby()、dropwhile()等大量函数也可以对列表进行操作。

Python高阶函数使用

1.Lambda函数：创建匿名函数，即没有名称的函数。它只是一个表达式，函数体简洁。

语法：lambda arguments(参数) : expression(表达式)

func1=lambda a,b:a+b
result=func1(2,6)
print("result=",result)

2.Map函数：根据提供的函数对指定序列做映射

语法：map(function, iterable, ...) 其中，function -- 函数，iterable -- 一个或多个序列

lst=[1,2,3,4,5]
result=map(lambda x:x*2,lst)
print(result,list(result)) #<map object at 0x0000020A0B0F0EA0> [2, 4, 6, 8, 10]

3.Reduce函数：当需要对一个列表进行一些计算并返回结果时，reduce()是个非常有用的函数，如求和，求阶乘之类的。

需要引入functools模块来调用 reduce()函数：from functools import reduce

语法：

reduce(function, iterable[, initializer])，

其中参数function -- 函数，有两个参数；iterable -- 可迭代对象；initializer -- 可选，初始参数 reduce将函数作用在一个列表上，映射函数接收了两个参数，reduce()把结果继续和列表的下一个元素做累加计算

4.enumerate函数

enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中

语法：enumerate(iterable, start=0)

它的两个参数，一个是序列、迭代器或其他支持迭代对象；另一个是下标起始位置，默认情况从0开始

5.Zip函数

语法：zip（可迭代对象，.....）

zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表

当我们使用zip()函数时，如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

print(list(zip(range(1,4)))) #[(0, 1), (1, 2), (2, 3)]
print(list(zip(['a','b','c'],[1,2]))) #[('a', 1), ('b', 2)]

6. Filter函数

filter()函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表

语法: filter(function, iterable)

其中，function -- 判断函数；iterable -- 可迭代对象。

返回filter object 迭代器对象

7.sorted函数：可以对序列进行排序，默认是升序，使用reverse参数调整排序方向，使用key参数，可以将序列中的元素按key参数指定的方法执行。

2.2、Tuple（元组）

从形式上，元组的所有元素放在一对圆括号中，元素之间使用逗号分隔，

如果元组中只有一个元素则必须在最后增加一个逗号。

定义后元组中元素的数量和引用不允许改变。

>>> x = (1, 2, 3) # 直接把元组字面值赋值给一个变量

>>> type(x) # 使用type()函数查看变量类型

<class 'tuple'>

>>> x[0] # 元组支持使用下标访问特定位置的元素

1

>>> x[-1] # 最后一个元素，元组也支持双向索引

3

>>> x[1] = 4 # 元组是不可变的

TypeError: 'tuple' object does not support item assignment

>>> x = 3, # 真正创建元组的是逗号，圆括号只是辅助

>>> x

(3,)

很多内置函数的返回值也是包含了若干元组或者可以生成若干元组的可迭代对象，例如enumerate()、zip()等等。

print(list(enumerate(range(5))))#[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
print(list(zip(range(3),'abcdefg')))#[(0, 'a'), (1, 'b'), (2, 'c')]

元组属于不可变（immutable）序列，一旦定义，其元素的数量和引用都是不可变的，不可以直接修改元组中元素的引用，也无法为元组增加或删除元素。

元组没有提供append()、extend()和insert()等方法，无法向元组中添加元素；同样，元组也没有remove()和pop()方法，也不支持对元组元素进行del操作，不能从元组中删除元素。

元组也支持切片操作，但是只能通过切片来访问元组中的元素，不允许使用切片来修改元组中元素的值，也不支持使用切片操作来为元组增加或删除元素。

2.3、Dictionary（字典）

dictionary（字典） 是 除列表以外 Python 之中 最灵活 的数据类型

字典同样可以用来 存储多个数据

通常用于存储 描述一个 物体 的相关信息

和列表的区别

列表 是 有序 的对象集合

字典 是 无序 的对象集合

字典用 {} 定义 字典使用 键值对 存储数据，键值对之间使用 , 分隔

键 key 是索引

值 value 是数据

键 和 值 之间使用 : 分隔

键必须是唯一的

值 可以取任何数据类型，但 键 只能使用 字符串、数字或 元组

1.使用赋值运算符"="将一个字典赋值给一个变量即可创建一个字典变量。

>>> aDict = {'server': 'db.diveintopython3.org', 'database': 'mysql'}

2. 也可以使用内置类dict以不同形式创建字典。

>>> x = dict() # 空字典

>>> type(x) # 查看对象类型

<class 'dict'>

>>> x = {} # 空字典

>>> keys = ['a', 'b', 'c', 'd']

>>> values = [1, 2, 3, 4]

>>> d = dict(zip(keys, values)) # 根据已有数据创建字典

>>> d = dict(name='Dong', age=39) # 以关键参数的形式创建字典

>>> d = dict.fromkeys([3, 5, 7], []) # 所有元素的"值"引用同一个空列表

>>> d

{3: [], 5: [], 7: []}

>>> d[3].append(666) # 所有元素的"值"都是一样的

>>> d

{3: [666], 5: [666], 7: [666]}

>>> d[3] = 999 # 修改一个元素"值"的引用

此后和其他的"值"再也没有关系了

>>> d

{3: 999, 5: [666], 7: [666]}

3.还可以使用字典推导式来创建字典。

>>> {num: chr(num) for num in range(97, 103)}

{97: 'a', 98: 'b', 99: 'c', 100: 'd', 101: 'e', 102: 'f'}

1. 字典中的每个元素表示一种映射关系或对应关系，根据提供的"键"作为下标就可以访问对应的"值"，如果字典中不存在这个"键"会抛出异常。

2.可以使用选择结构或异常处理结构来避免"键"不存在时代码崩溃抛出异常。

3.字典对象提供了一个get()方法用来返回指定"键"对应的"值"，并且允许指定该键不存在时返回特定的"值"。

4.使用字典对象的items()方法可以返回字典的键、值对，keys()方法可以返回字典的键，values()方法可以返回字典的值。

当以指定"键"为下标为字典元素赋值时，有两种含义：

1）若指定的"键"存在，表示修改该"键"对应的值；

2）若指定的"键"不存在，表示添加一个新的"键:值"对，也就是添加一个新元素。

使用字典对象的update()方法可以将另一个字典的"键:值"元素一次性全部添加到当前字典对象中，如果两个字典中存在相同的"键"，则以另一个字典中的"值"为准。

如果需要删除字典中指定的元素，可以使用del命令。

也可以使用字典对象的pop()和popitem()方法删除元素

2.4、Set（集合）

集合（set）属于Python无序可变容器对象，使用一对大括号作为定界符，元素之间使用逗号分隔，同一个集合内的每个元素都是唯一的，元素之间不重复。

集合中只能包含数字、字符串、元组等不可变类型（或者说可哈希）的数据，不能以任何形式包含列表、字典、集合等可变类型的数据。

1.直接将集合字面值赋值给变量即可创建一个集合对象

2.也可以使用函数set()函数将列表、元组、字符串、range对象或其他有限长度的可迭代对象转换为集合，并自动去除重复元素；如果原可迭代对象中有不可哈希的值，无法转换成为集合，抛出异常。

3.还可以使用集合推导式创建集合

（1）集合元素增加与删除

使用集合对象的add()方法可以增加新元素，如果该元素已存在则忽略该操作，不会抛出异常； update()方法用于合并另外一个或多个集合中的元素到当前集合中，并自动去除重复元素；

>>> s = {1, 2, 3}

>>> s.add(3) # 添加元素，重复元素自动忽略

>>> s

{1, 2, 3}

>>> s.update({3,4}) # 更新当前字典，自动忽略重复的元素

>>> s

{1, 2, 3, 4}

pop()方法用于随机删除并返回集合中的一个元素，如果集合为空则抛出异常；

remove(value)方法用于删除集合中的元素，如果指定元素不存在则抛出异常；

discard(value)用于从集合中删除一个特定元素，如果元素不在集合中则忽略该操作；

clear()方法清空集合删除所有元素。

可以使用集合快速提取序列中单一元素，即提取出序列中所有不重复元素

2.5、列表推导式

列表推导式使用非常简洁的方式来快速生成满足特定需求的列表，对原可迭代对象中的元素进行计算或过滤，代码具有非常强的可读性。

列表推导式语法形式为： [expression for expr1 in sequence1 if condition1

for expr2 in sequence2 if condition2

for expr3 in sequence3 if condition3

...

for exprN in sequenceN if conditionN]

列表推导式在逻辑上等价于一个循环语句，只是形式上更加简洁，但代码执行效率并不比循环结构高。

>>> aList = [x*x for x in range(10)]

相当于

>>> aList = []

>>> for x in range(10):

aList.append(x*x)

2.6、列表切片

切片用来访问有序序列中的部分元素。在形式上，切片使用2个冒号分隔的3个数字来完成。 [start:end:step]

第一个数字start表示切片开始位置，默认为0；

第二个数字end表示切片截止（但不包含）位置（默认为列表长度）；

第三个数字step表示切片的步长（默认为1）。

当start为0时可以省略，当step为1时可以省略，省略步长时还可以同时省略最后一个冒号；step为正整数时省略end表示一直切到最后一个元素，step为负整数时省略end表示一直切到第一个元素。

step为负整数时表示反向切片，这时start应该在end的右侧才行，否则返回结果为空。

（1）使用切片获取列表部分元素

使用切片可以返回列表中部分元素组成的新列表，其中包含原列表中部分元素的引用。与使用索引作为下标访问列表元素的方法不同，切片操作不会因为下标越界而抛出异常，而是简单地截断或者返回一个空列表，代码具有更强的健壮性。

>>> aList = [3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> aList[::] # 返回包含原列表中所有元素的新列表

[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> aList[::-1] # 返回包含原列表中所有元素的逆序列表

[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]

>>> aList[::2] # 从下标0开始，隔一个取一个，获取偶数位置的元素

[3, 5, 7, 11, 15]

>>> aList[1::2] # 从下标1开始，隔一个取一个，获取奇数位置的元素

[4, 6, 9, 13, 17]

>>> aList[3:6] # 返回下标[3,6)之间的元素

[6, 7, 9]

>>> aList[0:100] # 切片结束位置大于列表长度时，从列表尾部截断

[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

>>> aList[100] # 抛出异常，不允许越界访问

IndexError: list index out of range

>>> aList[100:] # 切片开始位置大于列表长度时，返回空列表

[]

>>> aList[-15:3] # 起始位置小于左边界，在开始处截断

[3, 4, 5]

>>> len(aList)

10

>>> aList[3:-10:-1] # 位置3在位置-10的右侧，-1表示反向切片

[6, 5, 4]

>>> aList[3:-5] # 位置3在位置-5的左侧，正向切片

[6, 7]

（2）使用切片为列表增加元素 可以使用切片操作在列表任意位置插入新元素，不影响列表对象的内存地址，属于原地操作。切片在等号左侧时用来标记位置，并没有真的切出来。

>>> aList = [3, 5, 7]

>>> aList[len(aList):]

[]

>>> aList[len(aList):] = [9] # 在列表尾部增加元素

>>> aList[:0] = [1, 2] # 在列表头部插入多个元素

>>> aList[3:3] = [4] # 在列表中间位置插入元素

>>> aList

[1, 2, 3, 4, 5, 7, 9]

（3）使用切片替换和修改列表中的元素

>>> aList = [3, 5, 7, 9]

>>> aList[:3] = [1, 2, 3] # 替换列表元素，等号两边的列表长度相等

>>> aList

[1, 2, 3, 9]

>>> aList[3:] = [4, 5, 6] # step=1时等号两边的列表长度可以不相等

>>> aList

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

>>> aList[::2] = [0] * 3 # 隔一个修改一个，切片步长不为1

此时等号两边的元素数量必须相等

>>> aList [0, 2, 0, 4, 0, 6]

>>> aList[::2] = ['a', 'b', 'c'] # 隔一个修改一个，等号两侧长度相等

>>> aList

['a', 2, 'b', 4, 'c', 6]

（4）使用切片删除列表中的元素

>>> aList = [3, 5, 7, 9]

>>> aList[:3] = [] # 删除列表中前3个元素，切片步长必须为1

>>> aList

[9]

也可以结合使用del命令与切片结合来删除列表中的部分元素，此时切片可以不连续，不要求step必须为1。

>>> aList = [3, 5, 7, 9, 11]

>>> del aList[:3] # 切片元素连续

>>> aList

[9, 11]

3.Python函数

3.1 函数定义

在Python中函数定义语法如下：

def function_name(arg1,arg2[,...])：

statement

[return value]

函数参数和返回值不是必须的，如果没有return语句，则Python函数默认返回值为None 。

3.2 函数参数

实参和形参

def greet_user(username):
    """显示简单问候语"""
    print(f"Hello,{username.title()}!")
greet_user('jesse')

形参（parameter）：username，即函数完成工作所需的信息。

实参（argument） ：'jesse' ，即在调用函数时传递的信息。

单向传递：在函数内部直接修改形参的引用不会影响实参

双向传递：可以通过下标或可变对象自身提供的原地修改方法在函数内部修改实参的值

也就是说，如果传递给函数的实参是可变对象，并且在函数内部使用下标或可变对象自身的方法增加、删除元素或修改元素时，实参也得到相应的修改

位置实参：基于实参的顺序进行关联

关键字实参：基于名称将值进行关联，函数不会混淆，不需要考虑参数顺序

在编写函数时，可以给每个形参指定默认值，称为可选参数，必须定义在非可选参数的后面

形参---可变长度参数

可变长度参数主要有两种形式：定义函数时在形参名称前面加1个或2个星号。

*parameter用来接收多个位置参数并将其放在一个元组中，元组长度取决于实际接收的位置参数个数；

**parameter用来接收多个关键参数并存放到一个字典中，字典中元素个数取决于实际接收的关键参数个数。

函数形参数分类

形式参数：def function(arg1,arg2,...)

关键字参数：def function(arg=value,...)

元组参数：def function(*arg)

字典参数：def function(**arg)

参数使用规则： 关键字参数必须在形式参数之后；

在单个函数定义中，只能使用一个tuple参数（*arg）和一个字典参数（**arg）；

tuple 参数必须在连接形式参数和关键字参数之后；

字典参数必须在所有其它参数最后定义。

函数返回值

总结：函数返回元组值，或者空元组，或者None。

4.类与对象定义

声明类

（1）构造函数------绑定数据

class Coordinate(object):
    def __init__(self,x,y):
        self.x=x
        self.y=y
        self.name=None

所有的实例变量都应在构造函数内赋值（初始化），除了self参数不需要赋值。 前两句绑定传入的数据。由于没有传入与name有关的数据，将name赋值为None。

（2）创建实例

class Coordinate(object):
    def __init__(self,x,y):
        self.x=y
        self.y=x
        self.name=None
data1=Coordinate(1,2)
print(data1.x,data1.y) #2 1

（3）直接访问和修改内部数据

print(data1.x,data1.y) #2 1
data1.x=10
print(data1.x,data1.y) #10 1