一、基本语法部分

1.简单数据类型

1.1字符串类型及操作

字符串访问：

1.索引访问

python 复制代码

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

2.切片访问

>>> 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'}

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

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)

>>> 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 函数参数

实参和形参

python 复制代码

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）构造函数------绑定数据

python 复制代码

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

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

（2）创建实例

python 复制代码

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）直接访问和修改内部数据

python 复制代码

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

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

一、基本语法部分

1.简单数据类型

1.1字符串类型及操作

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

2.4、Set（集合）

2.5、列表推导式

2.6、列表切片

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

3.Python函数

3.1 函数定义

3.2 函数参数

4.类与对象定义