Python基础知识

1.基本数据类型

• 整型（Integers）：正或负整数，不带小数点。例如：100，-786，0。

• 浮点型（Floating point numbers）：正或负浮点数，即带有小数点的数字。例如：15.20，0.0，-21.9，32.3+e18。

• 复数（Complex Numbers）：包含实部和虚部的数字，例如：3.14j，45.j，9.322e-36j。

• 布尔型（Boolean）：有两个值，True 和 False，通常用于条件判断。

• 字符串（String）：由零个或多个字符组成的有序字符序列。例如：'hello'，"world"。字符串是不可变的，即一旦创建了一个字符串，就不能修改它。

• 列表（List）：有序的集合，可以随时添加和删除其中的元素。例如：[1, 2, 3]，['a', 'b', 'c']。

• 元组（Tuple）：与列表类似，但元组是不可变的，即一旦创建了一个元组，就不能修改它。例如：(1, 2, 3)，('a', 'b', 'c')。

• 集合（Set）：无序且不重复的元素集合。例如：{1, 2, 3}，{'a', 'b', 'c'}。

• 字典（Dictionary）：无序的键值对集合，每个键唯一对应一个值。例如：{'name': 'Alice', 'age': 25}

2.基本数据结构

1、 列表:

    列表（list）是一种基本的数据结构，用于存储一系列有序的项目。列表中的项目可以是任意类      型，包括数字、字符串、其他列表等，且列表中的元素不必具有相同的类型。列表是动态的，这意味着你可以添加、删除或修改列表中的元素。

    创建方式[ ]

    创建一个包含不同方式的列表：my_list = [6, "hello", 2.56, [7, 8, 9]]

    创建一个空列表：empty_list = [] 

    创建一个包含多个相同元素的列表 ：repeated_list = [42] * 5   # result： [42, 42, 42, 42, 42]

   访问列表:

    第一个元素(索引位从0开始)：first_element = my_list[0]，最后一个元素可用-1，倒数第二个元      素可用-2，以此类推

my_list=['King','Apple','Courage','interrupt']
first_element = my_list[0]
print(first_element)
#结果为：king

    修改列表：

my_list=['King','Apple','Courage','interrupt']
my_list[0]='Lion'
first_element = my_list[0]
print(first_element)
#结果为：Lion

   添加元素：

   可以使用 append() 方法来向列表的末尾添加元素，或使用 insert() 方法在指定位置添加元素：

#使用append()方法来向列表的末尾添加元素
my_list=['King','Apple','Courage','interrupt']
my_list.append('King')
print(my_list)
#结果为：['King', 'Apple', 'Courage', 'interrupt', 'King']

  使用insert()在指定位置上插入：

#使用insert()在指定位置添加元素
my_list=['King','Apple','Courage','interrupt']
my_list.insert(2,'King')
print(my_list)
#结果为：['King', 'Apple', 'King', 'Courage', 'interrupt']

  删除元素：

  使用 remove() 方法来删除列表中第一个出现的指定元素，或使用 pop() 方法来删除并返回列表的最后一个元素，或者删除指定索引位置的元素：

#使用remove()删除元素
my_list=['King','Apple','Courage','interrupt']
my_list.remove('King')
print(my_list)
#结果为：['Apple', 'Courage', 'interrupt']

#使用pop()删除最后一个元素
my_list=['King','Apple','Courage','interrupt']
my_list.pop()
print(my_list)
#结果为：['King', 'Apple', 'Courage']

#删除指定索引位置的元素
my_list=['King','Apple','Courage','interrupt']
my_list.pop(1)
print(my_list)
#结果为：['King', 'Courage', 'interrupt']

    列表的常用操作：

• len(list)：返回列表的长度

  #返回列表长度
  my_list1=['King','Apple','Courage','Interrupt','Loop']
  my_list2=[6,7,8]
  result=my_list1+my_list2
  print(len(result))
  #结果为：8

• list1 + list2：连接两个列表

  #连接两个列表
  my_list1=['King','Apple','Courage','Interrupt','Loop']
  my_list2=[6,7,8]
  result=my_list1+my_list2
  print(result)
  #结果为：['King', 'Apple', 'Courage', 'Interrupt', 'Loop', 6, 7, 8]

• list1 * n：将列表重复n次。

  #将列表重复两次
  my_list2=[6,7,8]
  result=my_list2*2
  print(result)
  #结果为：[6, 7, 8, 6, 7, 8]

• list[start:end]：返回列表中从start到end（不包括end）的切片。

  #返回列表中从start到end（不包括end）的切片
  my_list2=[6,7,8]
  result=my_list2[1:2]
  print(result)
  #结果为：7

• in：检查一个元素是否在列表中。

  #检查一个元素是否在列表中
  my_list2=[6,7,8]
  print(6 in my_list2)
  #结果为：True
  print(9 in my_list2)
  #结果为：False

• max(list) 和 min(list)：返回列表中的最大值和最小值。

  #检查列表中的最大值
  my_list2=[6,7,8]
  print(max(my_list2))
  #结果为：8
  
  #检查列表中的最小值
  my_list2=[6,7,8]
  print(min(my_list2))
  #结果为：6

• list.sort()：对列表进行排序（原地排序）。

  #对列表进行排序（原地排序）
  my_list2=[6,7,8,9,10]
  my_list2.sort()
  print(my_list2)
  #结果为：[6, 7, 8, 9, 10]

• sorted(list)：返回一个新的已排序的列表。

#对列表进行排序
my_list2 = [6, 7, 8, 9, 10]
sort_list=my_list2.sort()
sorted_list = sorted(my_list2)
print(sort_list)#注意这里会输出 None
#当你尝试将 sort() 方法的返回值赋值给 sort_list 时，
# sort_list 会被赋值为 None，因为 sort() 方法本身不返回排序后的列表，而是修改原始列表
print(sorted_list)
#结果为：[6, 7, 8, 9, 10]

     

2、元组

在Python中，元组（tuple）是一种不可变（immutable）的序列类型，它允许你存储一个有序的集合。元组通常用圆括号 () 创建，元素之间用逗号分隔。由于元组是不可变的(静态的)，这意味着一旦创建了一个元组，就不能修改它的内容。这使得元组非常适合用于存储不需要修改的数据集合。

# 元组不可改变，因为是静态的
empty = (1,2,3,4,5)
empty[0]=6
print(empty)
#结果为：TypeError: 'tuple' object does not support item assignment

元组创建方式：( )

# 创建一个空元组  
empty = ()  

访问元组中的元素：

# 访问元组中的元素
empty = (1,2,3,4,5)
print(empty[0])
#结果为：1

元组支持索引、切片和序列运算，但不支持修改操作：

# 元组支持索引、切片和序列运算，但不支持修改操作
empty = (1,2,3,4,5)
print(empty[0:2])
#结果为：(1, 2)

将元组转换为列表：

# 将元组转换为列表
empty = (1,2,3,4,5)
change_data=list(empty)
print(change_data)
#结果为：[1, 2, 3, 4, 5]

将列表转换为元组：

# 将列表转换为元组
empty = [1,2,3,4,5]
change_data=tuple(empty)
print(change_data)
#结果为：(1, 2, 3, 4, 5)

列表和元素可以随意嵌套：

#列表或元组的元素可以是另一个列表或元组。这种嵌套特性在处理复杂数据结构时非常有用。
list=[[1,2,3],(1,2,3)];
tuple1=((1,2,3),[4,5,6]);
print(list)
#结果为：[[1, 2, 3], (1, 2, 3)]
print(tuple1)
#结果为：((1, 2, 3), [4, 5, 6])

列表与元组的存储方式：

# 列表与元组的存储方式
import sys
list1 = [1, 2, 3]
tuple1 = (1, 2, 3)
print(sys.getsizeof(list1))  # 输出 list1 的内存占用 120
print(sys.getsizeof(tuple1))  # 输出 tuple1 的内存占用 64

元组与列表之间的区别：

元组（Tuple）和列表（List）在Python中都是用于存储多个值的数据结构，但它们之间存在一些重要的区别：
可变性：
列表是可变的（Mutable），这意味着你可以修改列表中的元素，添加或删除元素。
元组是不可变的（Immutable），一旦创建，就不能修改其中的元素。尝试修改元组中的元素会引发TypeError。
语法：
列表使用方括号 [] 定义，例如 my_list = [1, 2, 3]。
元组使用圆括号 () 定义，例如 my_tuple = (1, 2, 3)。如果元组只有一个元素，需要在元素后面加上逗号，如 single_element_Tuple = (42,)。
性能：
由于元组是不可变的，Python在内部对元组进行了优化，使得元组的操作（如索引、切片等）通常比列表更快。
在处理大量数据或需要高效性能的场景下，元组通常优于列表。
使用场景：
当你需要一个可以修改的序列时，应该使用列表。
当你需要一个不可变的序列，例如用作字典的键或集合的元素时，应该使用元组。
方法支持：
列表支持更多的方法，如 append(), insert(), remove(), pop() 等，用于修改列表内容。
元组没有这些方法，因为它是不可变的。但元组仍然支持索引、切片和序列运算（如 + 和 *）。
元素类型：
列表通常用于存储相同类型数据的集合，但也可以包含不同类型的元素。
元组也可以包含不同类型的元素，但由于其不可变性，它们通常用于表示一组不会改变的数据。
嵌套：
列表和元组都可以嵌套，即一个列表或元组的元素可以是另一个列表或元组。这种嵌套特性在处理复杂数据结构时非常有用。
总的来说，列表和元组各有其用途，选择使用哪种取决于你的具体需求。如果你需要一个可以修改的序列，应该使用列表；如果你需要一个不可变的序列，应该使用元组。

3、字典

在Python中，字典（Dictionary）是一种无序的、可变的数据结构，用于存储键值对（key-value pairs）。每个键在字典中都是唯一的，可以用来快速查找对应的值。字典在Python中由大括号 {} 定义，键和值之间用冒号 : 分隔，不同的键值对之间用逗号 , 分隔。

字典用{ }号定义

# 创建一个空字典  
empty= {}  

创建一个包含几个键值对的字典

# 创建一个包含几个键值对的字典
person = {
    'name': 'Jake',  
    'age': 18,
    'city': 'California'
}
#在这里name、age、city是键(key)，Jake、18、California是值(value)

访问字典中的值  

# 访问字典中的值
person = {
    'name': 'Jake',
    'age': 18,
    'city': 'California'
}
print(person['name']) #结果为：Jake

 添加一个新的键值对  

# 添加一个新的键值对 
person = {
    'name': 'Jake',
    'age': 18,
    'city': 'California'
}
person['job']='Sortware Engineer'
print(person)
#结果为：{'name': 'Jake', 'age': 18, 'city': 'California', 'job': 'Sortware Engineer'}

修改一个已存在的键值对 

# 修改一个已存在的键值对 
person = {
    'name': 'Jake',
    'age': 18,
    'city': 'California'
}
person['job']='Sortware Engineer'
person['job']='Hardware engineer'
print(person)
#结果为：{'name': 'Jake', 'age': 18, 'city': 'California', 'job': 'Hardware engineer'}

 删除一个键值对  del

#删除一个键值对
person = {
    'name': 'Jake',
    'age': 18,
    'city': 'California'
}
del person['city']
print(person)
#结果为：{'name': 'Jake', 'age': 18}

检查一个键是否在"值"里  in

#检查一个键是否在字典中
person = {
    'name': 'Jake',
    'age': 18,
    'city': 'California'
}

print('name' in person)
#结果为：True

使用get函数可以获取值   get

#使用get()函数
person = {
    'name': 'Jake',
    'age': 18,
    'city': 'California'
}

print(person.get('name'))
#结果为：Jake

字典和集合

#字典是通过键（key）来访问值的，而不能通过索引
person = {
    'name': 'Jake',
    'age': 18,
    'city': 'California'
}
print(person[0]) #结果为KeyError: 0

#集合不支持索引操作，集合和列表不一样，集合是一个哈希表
person1={1,2,3}
print(person1[0])
#结果为：TypeError: 'set' object is not subscriptable

在Python中，字典的键不能是列表

字典的键需要是不可变类型的数据，例如整数、浮点数、字符串和元组。列表是可变类型的数据，因此不能作为字典的键。如果尝试使用列表作为字典的键，Python会抛出一个TypeError。

如果需要使用列表作为字典的键，可以考虑将列表转换为元组，因为元组是不可变的。但请注意，如果元组中的元素本身是可变的（如另一个列表），那么整个元组仍然不能被用作字典的键，因为元组的不可变性仅适用于其包含的元素，而不适用于这些元素的内容。

#字典不能是一个列表
person = {
    'name': 'Jake',
    ['city']: ['California']
}
print(person)
#结果为：person = {TypeError: unhashable type: 'list'

#字典可以是一个元组
person = {
    'name': 'Jake',
    ('city'): ('California')
}
print(person)
#结果为：{'name': 'Jake', 'city': 'California'}

字典的复制（浅复制）

#字典可以被浅复制
person = {
    'name': 'Jake',
    'city': 'California'
}
copied_dict = person.copy()
print(copied_dict)
#结果为：{'name': 'Jake', 'city': 'California'}

  4、集合

在Python中，集合（Set）是一个无序的、不重复的元素集合。集合用于存储唯一的元素，并且集合中的元素是无序的，即元素在集合中的位置是不重要的。集合用大括号 {} 定义，或者使用 set() 函数来创建。

   创建集合

# 使用大括号创建集合  
example = {1, 2, 3}  

使用set()函数创建集合  

# 使用set()函数创建集合
example= set([1, 2, 2, 3, 4, 4])  # 重复的元素会被自动去除
print(example)
#结果为：{1, 2, 3, 4}

空集合

# 空集合
example=set() # 重复的元素会被自动去除
print(example)
#结果为：set()

集合操作

• 交集：使用 & 运算符或 intersection() 方法

# 交集：使用 & 运算符或 intersection() 方法
example1 = {1, 2, 3, 4}
example2 = {3, 4, 5, 6}
intersection = example1 & example2#结果为：{3, 4}
intersection2=example1.intersection(example2)#结果为：{3, 4}
print(intersection)
print(intersection2)

• 并集：使用 | 运算符或 union() 方法

  #并集：使用 | 运算符或 union() 方法
  example1 = {1, 2, 3, 4}
  example2 = {3, 4, 5, 6}
  intersection = example1 | example2#结果为：{1, 2, 3, 4, 5, 6}
  intersection2=example1.union(example2)#结果为：{1, 2, 3, 4, 5, 6}
  print(intersection)
  print(intersection2)

• 差集：使用 - 运算符或 difference() 方法

  #差集：使用 - 运算符或 difference() 方法
  example1 = {1, 2, 3, 4}
  example2 = {3, 4, 5, 6}
  intersection = example1-example2#结果为：{1, 2}
  intersection2=example1.difference(example2)#结果为：{1, 2}
  print(intersection)
  print(intersection2)

• 对称差集：使用 ^ 运算符或 symmetric_difference() 方法

  #对称差集：使用 ^ 运算符或 symmetric_difference() 方法
  example1 = {1, 2, 3, 4}
  example2 = {3, 4, 5, 6}
  intersection = example1^ example2#结果为：{1, 2, 5, 6}
  intersection2=example1.symmetric_difference(example2)#结果为：{1, 2, 5, 6}
  print(intersection)
  print(intersection2)

5、字符串

在Python中，字符串是由零个或多个字符组成的有限序列。Python的字符串是不可变的，这意味着一旦一个字符串被创建，你就不能更改它。但是，你可以通过连接、切片、索引等操作来创建新的字符串。

创建字符串

#创建字符串
1、''
2、""
3、""" """
str='这是一个字符串'
str1="这是一个字符串"
str3="""
这是一个字符串
 """

运行结果：
这是一个字符串
这是一个字符串

这是一个字符串

索引：使用方括号和索引来访问字符串中的字符。索引从0开始

#索引
str= 'Python'
print(str[1])  # 输出 y
print(str[3])  # 输出 h

切片：使用方括号和切片来访问字符串的子串

#创建字符串
str= 'Python'
print(str[1:3])  # 输出 yt

连接：使用加号（+）来连接两个字符串

#连接
str1 = 'Hello'
str2= 'World'
print(str1 + ' ' + str2)  # 输出 'Hello World'

重复：使用乘号（*）来重复字符串

#重复
str= 'Python'
print(str* 3)  # 输出 PythonPythonPython

查找：使用find()或index()方法来查找子串在主串中的位置

#查找
str= 'Hello World'
print(str.find('World'))  # 输出 6  
print(str.index('World')) # 输出 6

替换：使用replace()方法来替换字符串中的子串

#替换
str= 'Hello World'
print(str.replace('World', 'Python'))  # 输出 'Hello Python'

分割：使用split()方法来根据指定的分隔符将字符串分割成列表

#分割
s = 'Hello,World'
print(s.split(','))  # 输出 ['Hello', 'World']

长度：使用len()函数来获取字符串的长度

#长度
str= 'Python'
print(len(str))  # 输出 6

注意事项：python字符串不可变

#Python字符串不可变
str= 'Python'
str[0]='H'
print(str)
#运行结果：TypeError: 'str' object does not support item assignment

#若想改变原字符 方法一
print(str.replace('P','H')) #运行结果：Hython
#方法二
new='S'+str[1:]
print(new) #运行结果：Sython

输出方式(暂且提供两种)

旧式字符串格式化（%操作符）：

使用%操作符和格式化字符串来格式化输出。格式化字符串可以包含%s（用于字符串）和%d（用于整数）等占位符。

str='Jake'
age=20
print("My name is %s and I am %d years old." % (str, age))
#输出结果：My name is Jake and I am 20 years old.

注意事项：%s表示字符串型，%d表示整型

str.format()方法

使用str.format()方法，你可以在字符串内部使用花括号{}作为占位符，并在format()方法中提供要插入的值。

#format方法
name='Jake'
age=20
print('My name is{} and I am {} years old'.format(name,age))
#输出结果：My name is Jake and I am 20 years old.

字符串总结

字符串的创建

• 使用单引号或双引号来创建字符串。
• 使用三引号（单引号或双引号）来创建多行字符串。

字符串操作

• 连接：使用 + 运算符来连接两个字符串。
• 重复：使用 * 运算符来重复字符串。
• 切片：使用切片语法来获取子字符串。
• 长度：使用 len() 函数来获取字符串的长度。
• 查找：使用 find() 或 index() 方法来查找子字符串的位置。
• 替换：使用 replace() 方法来替换子字符串。
• 分割：使用 split() 方法来根据分隔符将字符串分割成列表。
• 大小写转换：使用 lower(), upper(), capitalize(), title() 等方法来转换字符串的大小写。
• 去除空格：使用 strip(), lstrip(), rstrip() 方法来去除字符串两侧的空格。
• 格式化：使用 % 格式化，str.format() 方法，或 f-string（Python 3.6+）来格式化字符串

字符串方法

Python的字符串对象提供了许多内置方法，用于处理字符串数据。以下是一些常用的字符串方法：

• isalpha()：检查字符串是否只包含字母。
• isdigit()：检查字符串是否只包含数字。
• isalnum()：检查字符串是否只包含字母和数字。
• istitle()：检查字符串是否每个单词的首字母都大写。
• isspace()：检查字符串是否只包含空白字符。
• startswith() 和 endswith()：检查字符串是否以指定的前缀或后缀开始或结束。
• join()：使用指定的字符串连接序列中的元素。
• expandtabs()：将字符串中的制表符转换为空格。
• count()：计算子字符串在字符串中出现的次数。

不可变性

Python的字符串是不可变的，这意味着一旦创建了一个字符串，就不能修改它。如果需要修改字符串，通常会创建一个新的字符串。这种不可变性使得字符串操作在某些情况下更高效，但也意味着在需要频繁修改字符串时可能需要更多的内存。

字符串编码

在Python中，字符串是以Unicode编码存储的，这意味着它们可以表示任何语言的字符。然而，当与文件或网络进行交互时，可能需要将字符串编码为字节串（byte string），例如使用UTF-8编码。

性能考虑

由于字符串是不可变的，因此在处理大量字符串或进行大量字符串操作时，性能可能成为一个考虑因素。在这种情况下，可以使用字符串的 intern() 方法来缓存字符串对象，或者使用字节串和字节数组来提高性能。

3.条件语句与循环语句

在Python中，条件语句通常使用if，elif（相当于"else if"），和else关键字来实现。这些关键字允许你根据条件表达式的结果来执行不同的代码块。以下是一个基本的条件语句的示例

条件语句

#if else和elif方法
example = 6
if example > 0:
    print("example 是正数")
elif example  < 0:
    print("example 是负数")
else:
    print("example 是零")
#运行结果为：example 是正数

#与其他语句不同：
example = 6
if(example>0){
     print("example 是正数")
}
#python语句
example = 6
if example > 0:
    print("example 是正数")
#运行结果为：example 是正数

可以省略判断语句：

#python语句
example = 6
if example:
    print("输出结果为:"+str(example))
#运行结果为：6

#注意if example: 就是一个判断语句，它检查 example 的值。在 Python 中，数字 0 被认为是 False，
# 而所有非零数字都被认为是 True。因为 example 被赋值为 6，
# 这是一个非零数字，所以判断语句 if example: 的结果为 True，因此会执行下面的 print 语句。

循环语句

for循环

#for循环语句
example = [1,2,3,4,5]
for i in example:
    print(i)
#运行结果为：
1
2
3
4
5

遍历一个字符串  

# 遍历一个字符串
for example in 'hello':
    print(example)
#运行结果为：
h
e
l
l
o

遍历字典的键  

# 遍历字典的键
example= {'name': 'Alice', 'age': 25}
for key in example:
    print(key)
#运行结果为：
name
age

遍历字典的值

# 遍历字典的值
example= {'name': 'Alice', 'age': 25}
for key in example.values():
    print(key)
#运行结果为：
Alice
25

遍历字典的键和值

# 遍历字典的键和值
example= {'name': 'Alice', 'age': 25}
for key, value in example.items():
    print(key, value)
#运行结果为：
name Alice
age 25

字典注意事项

关于值和键的注意事项：如果要遍历值或者是键值对，需要通过其内置函数values()或者items()实现，其中values()返回字典的值的集合，items()返回键值对的集合。

range()函数

在Python中，range函数是一个非常常用的内置函数，它用于生成一个数字序列。range函数通常与for循环一起使用，以遍历一系列的数字

# range()函数
example=[1,2,3,4,5]
for index in range(0,len(example)):
    if index<6:
      print(example[index])
#运行结果为：
1
2
3
4
5

enumerate()函数

#enumerate()函数返回一个枚举对象，其中包含元组，每个元组包含两个元素：计数（从0开始）和值
fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(f"Index: {index}, Fruit: {fruit}") #字母f或F前缀用于字符串字面量表示这是一个格式化字符串
#另一种输出方式(结果相同)
    #print("Index: {}, Fruit: {}".format(index,fruit))
#运行结果为：
Index: 0, Fruit: apple
Index: 1, Fruit: banana
Index: 2, Fruit: cherry

continue语句

在Python中，continue语句用于跳过当前循环的剩余部分，并立即开始下一次迭代。它通常用于在循环内部某些条件下跳过某些特定的迭代。

#continue
for i in range(1, 11):
    if i % 2 == 0:
        continue
    print(i)

# 输出:
1
3
5
7
9

break语句

break语句用于立即退出当前循环。当break语句被执行时，循环会被立即停止，程序流程将继续在循环结构之后的第一条语句。

#break
for i in range(1, 11):
    if i == 5:
        break
    print(i)

# 输出:
1
2
3
4

for循环和while循环两者的使用场景

for循环

for循环通常用于遍历可迭代对象（如列表、元组、字典、集合或字符串等）的元素。当你需要按照某种顺序（如从前往后或从后往前）逐个处理这些元素时，for循环是最佳选择。

使用场景：

• 遍历列表、元组、字典、集合等数据结构。
• 遍历字符串中的字符。
• 遍历文件或网络资源的行。
• 遍历任何可迭代对象。

while循环

while循环则用于在条件为真时重复执行代码块。通常，当你不知道循环会执行多少次，或者需要根据某些条件动态决定循环何时结束时，你会使用while循环。

使用场景：

• 当循环次数未知时。
• 当需要根据条件动态控制循环次数时。
• 当需要实现无限循环时（通常配合break语句使用以跳出循环）。
• 当需要在循环中进行条件检查并根据条件进行迭代时。