Python基础篇(四)：基本数据类型的学习和示例

Python基础篇(三)：基本语句的示例和说明

1. 数值类型

在Python中，常见的数值类型包括整数（int）、浮点数（float）和复数（complex）。下面是对这些数值类型的介绍和示例：

1.1 整数（int）

• 表示整数值，没有小数部分。

• 示例：

  x = 10
  y = -5
  z = 0
  

• 整数操作示例

  
  x = 10
  y = 3
  
  print(x + y)    # 加法，输出 13
  print(x - y)    # 减法，输出 7
  print(x * y)    # 乘法，输出 30
  print(x / y)    # 除法，输出 3.3333333333333335
  print(x % y)    # 取模（取余），输出 1
  print(x // y)   # 整除，输出 3
  print(x ** y)   # 幂运算，输出 1000
  

1.2 浮点数（float）

• 表示带有小数部分的数值。

• 示例：

  pi = 3.14
  temperature = 98.6
  

• 浮点数操作示例:

  pi = 3.14
  radius = 2.5
  
  print(2 * pi * radius)   # 计算圆的周长，输出 15.7
  print(pi * radius ** 2)  # 计算圆的面积，输出 19.625
  

1.3 复数（complex）

• 表示具有实部和虚部的复数。

• 示例：

  z = 2 + 3j
  w = -1.5 + 0.5j
  

• 复数操作示例：

  # 复数示例
  z = 2 + 3j
  w = -1.5 + 0.5j
  
  print(z + w)   # 复数加法，输出 0.5 + 3.5j
  print(z * w)   # 复数乘法，输出 -3.5 + 1j
  print(z.conjugate())   # 求共轭复数，输出 2 - 3j
  

2. 字符串类型

在Python中，字符串（str）是一种表示文本数据的数据类型。字符串由一系列字符组成，并用引号（单引号或双引号）括起来。下面是对Python字符串类型的介绍和示例：

2.1 字符串的定义

• 字符串可以使用单引号或双引号括起来。
• 示例：

  message1 = 'Hello, world!'
  message2 = "Python is awesome!"
  

2.2 转义字符

• 转义字符用于在字符串中表示特殊字符，通常以反斜杠（\）开头。
• 示例：

  message = "She said, \"I'm fine.\""
  

下面是Python中常用的转义字符及其说明的表格：

转义字符	描述
\'	单引号
\"	双引号
\\	反斜杠
\n	换行
\t	水平制表符
\r	回车
\b	退格
\f	换页
\ooo	八进制数，其中 ooo 是一个 1-3 位的数字
\xhh	十六进制数，其中 hh 是一个两位的数字

使用转义字符可以在字符串中表示特殊字符，例如引号、换行、制表符等。以下是一些示例：

# 单引号和双引号
message1 = 'She said, \'Hello cxk!\''
message2 = "He said, \"Hi! cxk\""

# 换行和制表符
text = "Hello\n\tCxk!"

# 回车和退格
output = "Loading...\r100%"
text_with_backspace = "Hello\bCxk!"

# 八进制和十六进制
octal_char = "\101"    # 八进制数表示大写字母 "A"
hex_char = "\x41"      # 十六进制数表示大写字母 "A"

2.3 多行字符串

• 多行字符串可以使用三引号（三个连续的单引号或双引号）括起来。
• 示例：

  poem = '''
  Roses are red,
  Violets are blue,
  Sugar is sweet,
  And so are you，
  kun is basketball.
  '''
  

2.4 字符串运算

• 可以使用加号（+）将两个字符串拼接在一起。
• 示例：

  first_name = "蔡"
  last_name = "徐坤"
  full_name = first_name + " " + last_name
  

以下是Python中常用的字符串运算符及其说明的表格：

运算符	描述	示例
+	连接两个字符串	'Hello, ' + 'world!'
*	重复字符串	'Python' * 3
[]	获取字符串中的单个字符	'Hello'[0]
[x:y]	获取字符串中的子串	'Hello'[1:4]
in	判断子串是否存在于字符串中	'world' in 'Hello, world!'
not in	判断子串是否不存在于字符串中	'Alice' not in 'Hello, Bob'

示例：

greeting = 'Hello, '
name = '徐州蔡徐坤'

# 连接两个字符串
message = greeting + name
print(message)     # 输出: Hello, cxk

# 重复字符串
line = '-' * 10
print(line)        # 输出: ----------

# 获取单个字符
first_char = name[0]
print(first_char)  # 输出: A

# 获取子串
substring = name[1:4]
print(substring)   # 输出: lic

# 判断子串是否存在
is_contained = '坤' in greeting
print(is_contained)   # 输出: False

# 判断子串是否不存在
is_not_contained = '坤' not in greeting
print(is_not_contained)   # 输出: True

2.5 字符串格式化

• 使用占位符和格式化方法，可以将变量的值插入到字符串中。
• 示例：

  name = "CXK"
  age = 25
  message = "My name is {} and I'm {} years old.".format(name, age)
  

3. 列表类型

在Python中，列表（List）是一种有序、可变的数据类型，用于存储和操作多个元素。列表支持添加、插入、删除元素，以及通过索引访问和修改元素。列表使用方括号（[]）表示，元素之间用逗号分隔。

下面是对Python列表类型的介绍和示例：

3.1 列表的定义

• 列表是一组按特定顺序排列的元素集合。
• 示例：

  numbers = [1, 2, 3, 4, 5]
  names = ['Ai', 'book', 'chris']
  

3.2 访问列表元素

• 可以使用索引来访问列表中的特定元素。索引从0开始，负数索引表示从末尾开始倒数。
• 示例：

  numbers = [1, 2, 3, 4, 5]
  
  print(numbers[0])     # 输出: 1
  print(numbers[-1])    # 输出: 5
  

3.3 修改列表元素

• 可以通过索引来修改列表中的元素。
• 示例：

  numbers = [1, 2, 3, 4, 5]
  
  numbers[0] = 10
  print(numbers)    # 输出: [10, 2, 3, 4, 5]
  

3.4 列表操作

• 列表支持各种操作，如添加元素、删除元素、切片等。
• 示例：

     players = ['kobe', 'jordan', 'Lin']
     
     players.append('wade')  # 添加元素到列表末尾
     print(players)  # 输出:['kobe', 'jordan', 'Lin', 'wade']
     
     players.insert(1, 'curry')  # 在指定位置插入元素
     print(players)  # 输出: ['kobe', 'curry', 'jordan', 'Lin', 'wade']
     
     del players[2]  # 删除指定位置的元素
     print(players)  # 输出: ['kobe', 'curry', 'Lin', 'wade']
     
     players_slice = players[1:3]  # 切片操作，获取子列表
     print(players_slice)  # 输出:['curry', 'Lin']
  

3.5 列表长度和遍历

• 可以使用内置函数 len() 获取列表的长度，使用循环遍历列表中的元素。
• 示例：

     players = ['kobe', 'jordan', 'Lin', 'rose']
     
     print(len(players))  # 输出: 4
     for player in players:
        print(player)  # 依次输出:kobe,jordan,Lin,rose
  

4. 元组类型

在Python中，元组（Tuple）是一种有序的、不可变的数据类型，用于存储多个元素。由于元组不可修改，因此可以在需要存储不可变数据集合的场景下使用元组。元组使用圆括号（()）表示，元素之间用逗号分隔。

下面是对Python元组类型的介绍和示例：

4.1 元组的定义

• 元组是一组按特定顺序排列的元素集合，与列表类似，但元组是不可变的，即创建后不能修改。
• 示例：

  point = (2, 3)
  colors = ('red', 'green', 'blue')
  

4.2 访问元组元素

• 可以使用索引来访问元组中的特定元素。索引从0开始，负数索引表示从末尾开始倒数。
• 示例：

  point = (2, 3)
  
  print(point[0])     # 输出: 2
  print(point[-1])    # 输出: 3
  

4.3 元组的特性

• 元组是不可变的，即创建后不能修改元组中的元素。
• 示例：

  point = (2, 3)
  
  # 尝试修改元组中的元素，将会抛出错误
  point[0] = 10
  

  

4.4 元组的解包

• 可以将元组的元素解包到多个变量中。
• 示例：

  point = (2, 3)
  x, y = point
  
  print(x)    # 输出: 2
  print(y)    # 输出: 3
  

4.5 元组的应用

• 元组可以用于多个变量的赋值、函数返回多个值等场景。
• 示例：

  # 多个变量的赋值
  x, y, z = 1, 2, 3
  
  # 函数返回多个值
  def get_point():
      return 2, 3
  
  x, y = get_point()
  

5. 集合类型

在Python中，集合（Set）是一种无序、不重复的数据类型，用于存储多个唯一的元素。它支持添加、删除元素以及求交集、并集等集合操作，非常适合处理需要唯一性的数据集合。集合使用花括号（{}）表示，元素之间用逗号分隔。

下面是对Python集合类型的介绍和示例：

5.1 集合的定义

• 集合是一组唯一、无序的元素的集合。
• 示例：

  fruits = {'apple', 'banana', 'cherry'}
  

5.2 创建集合

• 可以使用花括号或者内置函数 set() 创建集合。
• 示例：

  # 使用花括号创建集合
  fruits = {'apple', 'banana', 'cherry'}
  
  # 使用set()函数创建集合
  numbers = set([1, 2, 3, 4, 5])
  

5.3 访问集合元素

• 由于集合是无序的，不能通过索引访问集合中的元素，只能判断元素是否存在于集合中。
• 示例：

  fruits = {'apple', 'banana', 'cherry'}
  
  if 'apple' in fruits:
      print("苹果在集合中")
  

5.4 集合操作

• 集合支持各种操作，如添加元素、删除元素、求交集、求并集等。
• 示例：

  fruits = {'apple', 'banana', 'cherry'}
  
  fruits.add('orange')         # 添加元素到集合
  print(fruits)                # 输出: {'apple', 'banana', 'cherry', 'orange'}
  
  fruits.remove('banana')      # 删除指定元素
  print(fruits)                # 输出: {'apple', 'cherry', 'orange'}
  
  numbers1 = {1, 2, 3, 4}
  numbers2 = {3, 4, 5, 6}
  
  intersection = numbers1 & numbers2   # 求交集
  print(intersection)          # 输出: {3, 4}
  
  union = numbers1 | numbers2  # 求并集
  print(union)                 # 输出: {1, 2, 3, 4, 5, 6}
  

5.5 集合的特性

• 集合中的元素是唯一的，不会存在重复的元素。
• 集合是可变的，可以添加和删除元素。
• 集合是无序的，元素没有特定的顺序。
• 示例：

  fruits = {'apple', 'banana', 'cherry', 'apple'}
  print(fruits)    # 输出: {'apple', 'banana', 'cherry'}
  

6. 字典类型

在Python中，字典（Dictionary）是一种无序的、可变的数据类型，用于存储键值对（key-value pairs）。它支持通过键访问值、添加和删除键值对，以及获取所有键和值的操作。字典在处理需要快速查找、关联和索引的数据时非常方便
字典使用花括号（{}）表示，每个键值对之间用冒号（:）分隔，键和值之间用逗号分隔。

下面是对Python字典类型的介绍和示例：

6.1 字典的定义

• 字典是一种无序的、键值对的集合，每个键值对由一个键和对应的值组成。
• 示例：

  person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
  

6.2 访问字典元素

• 可以使用键来访问字典中的值。
• 示例：

  person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
  
  print(person['name'])    # 输出: Alice
  print(person['age'])     # 输出: 25
  

6.3 修改字典元素

• 可以通过键来修改字典中的值。
• 示例：

  person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
  
  person['age'] = 26
  print(person)    # 输出: {'name': 'Alice', 'age': 26, 'city': 'New York'}
  

6.4 字典操作

• 字典支持各种操作，如添加键值对、删除键值对、获取所有键和值等。
• 示例：

  person = {'name': 'Alice', 'age': 25, 'city': 'New York'}
  
  person['gender'] = 'Female'     # 添加键值对
  print(person)                   # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York', 'gender': 'Female'}
  
  del person['age']               # 删除键值对
  print(person)                   # 输出: {'name': 'Alice', 'city': 'New York'}
  
  keys = person.keys()            # 获取所有键
  print(keys)                     # 输出: dict_keys(['name', 'city'])
  
  values = person.values()        # 获取所有值
  print(values)                   # 输出: dict_values(['Alice', 'New York'])
  

6.5 字典的特性

• 字典中的键是唯一的，不会存在重复的键。
• 字典是可变的，可以添加、修改和删除键值对。
• 字典是无序的，键和值之间没有特定的顺序。
• 示例：

  person = {'name': 'Alice', 'age': 25, 'city': 'New York', 'name': 'Bob'}
  print(person)    # 输出: {'name': 'Bob', 'age': 25, 'city': 'New York'}
  

7. 布尔类型

在Python中，布尔（Boolean）类型是一种表示真（True）和假（False）的数据类型。布尔类型在条件判断和逻辑运算中起到关键作用，可以帮助我们根据不同的条件进行分支控制和逻辑判断。在编写程序时，经常会使用布尔类型进行条件判断和逻辑运算，以便实现不同的行为和控制流程。

下面是对Python布尔类型的介绍和示例：

7.1 布尔类型的定义

• 布尔类型只有两个取值，即True（真）和False（假）。
• 示例：

  is_true = True
  is_false = False
  

7.2 布尔运算

• 布尔类型支持逻辑运算符（and、or、not）和比较运算符（==、!=、<、>、<=、>=）。
• 示例：

  x = 5
  y = 10
  
  result1 = x > 3 and y < 15   # and逻辑运算
  print(result1)              # 输出: True
  
  result2 = x < 3 or y > 15    # or逻辑运算
  print(result2)              # 输出: False
  
  result3 = not(x > 3)         # not逻辑运算
  print(result3)              # 输出: False
  
  result4 = x == 5             # 相等比较
  print(result4)              # 输出: True
  
  result5 = x != 5             # 不等比较
  print(result5)              # 输出: False
  

7.3 布尔类型的应用

• 布尔类型通常用于条件判断，例如在if语句、while循环等控制结构中。
• 示例：

  x = 5
  
  if x > 0:
      print("x是正数")       # 输出: x是正数
  
  is_even = x % 2 == 0
  
  if is_even:
      print("x是偶数")
  else:
      print("x是奇数")       # 输出: x是奇数
  

8. None类型

在Python中，None是一个特殊的常量，表示空值或缺失值。它是Python的空对象，表示一个不存在的对象或没有值的对象。

下面是对Python中None类型的介绍和示例：

8.1 None类型的定义

• None类型表示空值或缺失值，用于表示一个没有值的对象。
• 示例：

  x = None
  

8.2. None类型的特点

• None是一个常量，它不是任何数据类型的实例。
• None对象是唯一的，不可改变的。
• None类型在条件判断、函数返回值等场景中常用于表示没有有效值的情况。
• 示例：

  def find_max(numbers):
      if len(numbers) == 0:
          return None
      
      max_value = numbers[0]
      for num in numbers:
          if num > max_value:
              max_value = num
      
      return max_value
  
  numbers = [1, 2, 3, 4, 5]
  max_num = find_max(numbers)
  
  if max_num is None:
      print("列表为空")
  else:
      print("最大值为:", max_num)