Python 基础语法(一）

1. 列表和元组

在Python中，列表（list）和元组（tuple）都是用于存储多个对象的数据结构。它们之间有一些重要的区别，下面是一些关于列表和元组的基本知识：

列表（list）：

• 列表是可变的，这意味着你可以添加、删除或修改列表中的元素。
• 列表使用方括号 [] 来定义，其中的元素之间用逗号分隔。
• 列表中的元素可以是不同的数据类型，例如整数、浮点数、字符串等。
• 列表支持索引和切片操作，可以通过索引访问或修改列表中的特定元素。
• 你可以使用内置函数（例如 len() 和 append()）以及方法（例如 sort() 和 reverse()）来操作列表。

下面是一个示例列表的定义和操作：

pythonCopy codefruits = ['apple', 'banana', 'orange']
print(fruits)  # 输出: ['apple', 'banana', 'orange']

fruits.append('grape')
print(fruits)  # 输出: ['apple', 'banana', 'orange', 'grape']

fruits[1] = 'kiwi'
print(fruits)  # 输出: ['apple', 'kiwi', 'orange', 'grape']

元组（tuple）：

• 元组是不可变的，这意味着一旦创建，就不能修改元组中的元素。
• 元组使用圆括号 () 来定义，其中的元素之间用逗号分隔。
• 元组中的元素可以是不同的数据类型，就像列表一样。
• 元组也支持索引和切片操作。

下面是一个示例元组的定义和操作：

pythonCopy codeperson = ('John', 25, 'USA')
print(person)  # 输出: ('John', 25, 'USA')

name = person[0]
print(name)  # 输出: 'John'

需要注意的是，尽管元组是不可变的，但如果元组中的元素是可变的对象（例如列表），那么可以修改可变对象中的元素。

综上所述，列表适用于需要频繁修改数据的场景，而元组适用于那些不希望数据被修改的场景，例如表示一组常量值或者在函数返回多个值时使用元组。选择列表或元组取决于你的需求和数据的特性。

2. 字典和集合

字典是一系列由键(key)和值(value)配对组成的元素 的集合，在 Python3.7+，字典被确定为有序(注意:在 3.6 中，字典有序是一个 implementation detail，在 3.7 才正式成为语言特性，因此 3.6 中无法 100% 确保其有序 性)，而 3.6 之前是无序的，其长度大小可变，元素可以任意地删减和改变。相比于列表和元组，字典的性能更优，特别是对于查找、添加和删除操作，字典都能在常数时 间复杂度内完成。而集合和字典基本相同，唯一的区别，就是集合没有键和值的配对，是一系列无序的、唯一的 元素组合。

在Python中，字典（dictionary）和集合（set）是两种常用的数据结构，它们都用于存储和操作一组元素。下面是关于字典和集合的基本知识：

字典（dictionary）：

• 字典是无序的键值对集合，其中每个键（key）都唯一对应一个值（value）。
• 字典使用花括号 {} 来定义，其中的键值对以冒号 : 分隔，键值对之间用逗号分隔。
• 字典中的键必须是不可变的类型（如字符串、整数或元组），而值可以是任意类型。
• 字典中的元素是无序的，你不能通过索引访问它们，而是通过键来获取对应的值。
• 你可以使用内置函数（如 len() 和 del）以及方法（如 keys()、values() 和 items()）来操作字典。

下面是一个示例字典的定义和操作：

pythonCopy codestudent = {'name': 'John', 'age': 25, 'grade': 'A'}
print(student)  # 输出: {'name': 'John', 'age': 25, 'grade': 'A'}

student['school'] = 'XYZ High School'
print(student)  # 输出: {'name': 'John', 'age': 25, 'grade': 'A', 'school': 'XYZ High School'}

del student['grade']
print(student)  # 输出: {'name': 'John', 'age': 25, 'school': 'XYZ High School'}

集合（set）：

• 集合是无序、不重复的元素集合。
• 集合使用花括号 {} 或 set() 函数来定义，其中的元素之间用逗号分隔。
• 集合中的元素必须是不可变的类型（如字符串、整数或元组），而不能包含可变类型（如列表或字典）。
• 集合支持基本的集合操作，如并集、交集和差集，还提供了去重的功能。

下面是一个示例集合的定义和操作：

pythonCopy codefruits = {'apple', 'banana', 'orange'}
print(fruits)  # 输出: {'apple', 'banana', 'orange'}

fruits.add('kiwi')
print(fruits)  # 输出: {'apple', 'banana', 'orange', 'kiwi'}

fruits.remove('banana')
print(fruits)  # 输出: {'apple', 'orange', 'kiwi'}

需要注意的是，字典和集合中的元素是无序的，因此不能通过索引来访问它们。

字典适用于需要存储键值对数据的场景，例如存储联系人信息；而集合适用于需要存储唯一元素且不关心顺序的场景，例如去重操作或判断元素是否存在。

3. 字典和集合性能

电商企业的后台，存储了每件产品的 ID、名称和价格。现在的需求是，给定某件商品的 ID，我们要找出其价格。如果我们用列表来存储这些数据结构，并进行查找，相应的代码如下

def find_product_price(products, product_id):
    for id, price in products:
        if id == product_id:
            return price
return None
products = [
    (143121312, 100),
    (432314553, 30),
    (32421912367, 150)
]
print('The price of product 432314553 is {}'.format(find_product_price(products,432314553）

假设列表有 n 个元素，而查找的过程要遍历列表，那么时间复杂度就为 O(n)。即使我们先对 列表进行排序，然后使用二分查找，也会需要 O(logn) 的时间复杂度，更何况，列表的排序 还需要 O(nlogn) 的时间。

如果我们用字典来存储这些数据，那么查找就会非常便捷高效，只需 O(1) 的时间复杂度就 可以完成。原因也很简单，刚刚提到过的，字典的内部组成是一张哈希表，你可以直接通过键 的哈希值，找到其对应的值

products = {
2 143121312: 100,
3 432314553: 30,
4 32421912367: 150
5}
6 print('The price of product 432314553 is {}'.format(products[432314553])) 7
8 # 输出
9 The price of product 432314553 is 30

4. 条件语句

#y=|x|
ifx<0: y = -x
else: y=x   

和其他语言不一样，我们不能在条件语句中加括号，写成下面这样的格式。
if(x<0)

但需要注意的是，在条件语句的末尾必须加上冒号(，这是 Python 特定的语法规范。 由于 Python 不支持 switch 语句，因此，当存在多个条件判断时，我们需要用 else if 来实

现，这在 Python 中的表达是 elif。语法如下:

if condition_1:
    statement_1
elif condition_2:
    statement_2
...
elif condition_i:
    statement_i
else:
statement_n

5. 错误与异常

 try:
s = input('please enter two numbers separated by comma: ')
num1 = int(s.split(',')[0].strip())
num2 = int(s.split(',')[1].strip())

except ValueError as err:
print('Value Error: {}'.format(err))

print('continue')

这里默认用户输入以逗号相隔的两个整形数字，将其提取后，做后续的操作(注意 input 函数 会将输入转换为字符串类型)。如果我们输入a,b，程序便会抛出异常invalid literal for int() with base 10: ‘a’，然后跳出 try 这个 block。

由于程序抛出的异常类型是 ValueError，和 except block 所 catch 的异常类型相匹配，所以 except block 便会被执行，最终输出Value Error: invalid literal for int() with base 10: ‘a’，并打印出continue。

我们知道，except block 只接受与它相匹配的异常类型并执行，如果程序抛出的异常并不匹 配，那么程序照样会终止并退出。

所以，还是刚刚这个例子，如果我们只输入1，程序抛出的异常就是IndexError: list index out of range，与 ValueError 不匹配，那么 except block 就不会被执行，程序便 会终止并退出(continue 不会被打印)。

不过，很显然，这样强调一种类型的写法有很大的局限性。那么，该怎么解决这个问题呢? 其中一种解决方案，是在 except block 中加入多种异常的类型，比如下面这样的写法:

try:
    s = input('please enter two numbers separated by comma: ')
    num1 = int(s.split(',')[0].strip())
    num2 = int(s.split(',')[1].strip())
    ...
except ValueError as err:
    print('Value Error: {}'.format(err))
except IndexError as err:
    print('Index Error: {}'.format(err))
except Exception as err:
    print('Other error: {}'.format(err))
print('continue')

异常处理中，还有一个很常见的用法是 finally，经常和 try、except 放在一起来用。无论发 生什么情况，finally block 中的语句都会被执行，哪怕前面的 try 和 excep block 中使用了 return 语句。

一个常见的应用场景，便是文件的读取:
import sys
try:
    f = open('file.txt', 'r')
    .... # some data processing
except OSError as err:
    print('OS error: {}'.format(err))
except:
    print('Unexpected error:', sys.exc_info()[0])
finally:
f.close()

这段代码中，try block 尝试读取 file.txt 这个文件，并对其中的数据进行一系列的处理，到最 后，无论是读取成功还是读取失败，程序都会执行 finally 中的语句——关闭这个文件流，确 保文件的完整性。因此，在 finally 中，我们通常会放一些无论如何都要执行的语句。