What are the basic data types and common syntax in Python?

Integer

In Python, integer (integer) is a built-in data type used to represent integer values. The integer type in Python can represent integers of any size without considering the computer word length limit. This is because Python automatically adjusts the number of bits in integer types as needed so that integers of any size can be stored.

The following are some examples of integers:

x = 42          # 整数常量
y = -123        # 负整数常量
z = 0           # 零
#除法操作返回的结果可以是整数或浮点数，具体取决于操作数的类型和结果。如果除法的操作数都是整数，则结果为整数，如果有一个操作数是浮点数，则结果为浮点数。
x = 10
y = 3
print(x + y)      # 输出结果为13
print(x / y)      # 输出结果为3.3333333333333335
#在上面的示例中，我们定义了两个整数x和y，然后对它们进行了加法和除法操作，并打印了结果。注意，除法操作返回的结果是一个浮点数，而不是整数。如果要将结果转换为整数，可以使用`int()`函数进行转换。例如：
x = 10
y = 3
result = int(x / y)
print(result)      # 输出结果为3

In Python, for the representation of large numbers, you can directly use integers or long integers (long integer) without using scientific notation. .

In Python 2.x, the size of integers is limited, and the maximum value is 2^31 - 1. If you need to represent larger integers, you can use long integers. Long integers have no size limitation when represented, as they can automatically adjust their size to fit the required precision.. An integer literal can be marked as a long using the "L" suffix, for example: 12345678901234567890L.

In Python 3.x, integers no longer have value size restrictions and can directly represent extremely large integers without using long integers. In Python 3.x, long integers have been integrated into ordinary integers, so no additional markup or syntax is needed when representing large numbers.

For example, in Python a very large integer can be represented like this:

x = 123456789012345678901234567890

null value

When talking about null values ​​in Python, we can look at it is a placeholder used to represent no value or a null value.

In Python, a null value is represented by a built-in object None. This object is special and can be used as a placeholder of any type. When a variable is not assigned a value or a function return value requires a placeholder, we usually use None to represent a null value. Here is a simple example showing how to use None:

x = None      # 将变量x设置为None
y = 10        # 将变量y设置为一个整数值
z = None      # 将变量z设置为None

if x is None:
    print("x is None")
else:
    print("x is not None")

In the above example, we first change the variables x and z Set to None. Then, we use the is operator to check if the variable x is None. Since x is indeed None, the condition if x is None is established and "x is None" is printed. Conversely, if the variable x contains any other value (such as an integer value), the condition will not hold.

It should be noted that None is different from an empty string or an empty list. An empty string means no characters, and an empty list means no elements. In contrast, None is an object that represents no value or a null value. Therefore, None should be understood and used correctly when writing Python code to avoid confusion and errors.

Floating point number

In Python, floating point number is a built-in data type used to represent real numbers. Unlike integer types, floating point numbers are approximations, not exact values. This is because Python uses a double-precision floating-point format to represent floating-point numbers. This format can represent very large and very small numbers, but can cause some precision issues due to approximation and rounding errors. Therefore, when working with floating point numbers, you need to be aware of rounding errors and precision issues.

In Python, you can use decimal points to represent floating point numbers, or you can use scientific notation. For example, here are some examples of floating point numbers:

x = 3.14159      # 浮点数常量
y = -0.0001      # 负浮点数常量
z = 2.0e-6       # 科学计数法表示的浮点数（0.000002）
#Python中的浮点数可以执行各种算术操作，如加法、减法、乘法和除法等。下面是一个简单的示例，计算三个浮点数之和：
x = 0.1
y = 0.2
z = 0.3
print(x + y + z)   # 输出结果为0.6000000000000001
#Python中的浮点数可以执行各种算术操作，如加法、减法、乘法和除法等。下面是一个简单的示例，计算三个浮点数之和：
x = 0.1
y = 0.2
z = 0.3
print(x + y + z)   # 输出结果为0.6000000000000001
#在上面的示例中，我们计算三个浮点数之和，并打印结果。然而，输出结果并不是期望的0.6，而是一个近似值0.6000000000000001。这是由于浮点数的近似性和舍入误差导致的。为了避免这种问题，我们可以使用`round()`函数对浮点数进行四舍五入，以便得到更精确的结果。例如：
x = 0.1
y = 0.2
z = 0.3
result = round(x + y + z, 2)   # 对浮点数进行四舍五入，并保留两位小数
print(result)   # 输出结果为0.6

In the above example, we use the round() function to round a floating point number to two decimal places. Then, we print the result and get the expected 0.6.

And, or, not, operators

There are three types of logical operators in Python: AND operation (and), or operation (or) and not operation (not). These logical operators can be used on Boolean type values ​​(True or False) as well as other types of values.

Usage is as follows:

#1.  与运算
#与运算（`and`）用于判断两个条件是否都为True。如果两个条件都为True，则返回True，否则返回False。以下是与运算的一些示例：
x = 5
y = 10
result = x < 10 and y > 5
print(result)      # 输出结果为True
#在上面的示例中，我们使用与运算符`and`判断两个条件是否都为True，并打印了结果
#2.  或运算
#或运算（`or`）用于判断两个条件中是否有至少一个为True。如果两个条件都为False，则返回False，否则返回True。以下是或运算的一些示例：
x = 5
y = 10
result = x < 10 or y < 5
print(result)      # 输出结果为True
#在上面的示例中，我们使用或运算符`or`判断两个条件中是否有至少一个为True，并打印了结果。
#3.  非运算
#非运算（`not`）用于对一个条件进行取反操作，如果条件为True，则返回False，如果条件为False，则返回True。以下是非运算的一些示例：
x = 5
result = not x > 10
print(result)      # 输出结果为True
#在上面的示例中，我们使用非运算符`not`对一个条件进行取反操作，并打印了结果。
#总之，在Python中，逻辑运算符可以用于布尔类型的值（True或False），也可以用于其他类型的值。这些逻辑运算符包括与运算（`and`）、或运算（`or`）和非运算（`not`），可以用于各种逻辑操作中。

Character encoding

Because computers were invented by foreigners, they could only recognize uppercase and lowercase English letters, numbers and some symbols at first. These are passed ASCII is implemented by encoding. As shown in the figure below, the encoding of B is 66 and the encoding of 1 is 49;

With the development of computers and the Internet, every country in the world must use it, ASCII The encoding is obviously not enough to represent Chinese and other characters. In the process, China formulated GB2312, and South Korea formulated its own encoding formats such as Euc-kr. In order to prevent conflicts, later The Unicode character set was born, which unified all encodings and solved the problem of garbled characters caused by encoding conflicts. Later, a more cost-saving "variable length encoding" was derived UTF- 8 Encoding.

Let’s sort out the differences between ASCII, Unicode, UTF-8:

ASCII, Unicode and UTF-8 are both character encoding standards for converting characters into binary numbers for computer processing. The main difference between them is the encoding method and the character set that can be represented.

ASCII是一种最早的字符编码标准，它定义了 128 个字符，包括英文字母、数字和一些标点符号等基本符号。ASCII采用7位二进制编码表示字符，可以表示的字符范围是 0-127。

Unicode是一种用于表示字符集的标准，它定义了世界上几乎所有的字符集，包括中文、日文、韩文等各种语言的字符。Unicode使用32位二进制编码表示字符，可以表示的字符范围非常广泛，包括标点符号、表情符号、数学符号等等。

UTF-8 是 Unicode 的一种编码方式，它是一种可变长度编码方式，能够表示Unicode中的任何字符，包括中文、日文、韩文等各种语言的字符。UTF-8对于英文字母、数字和常用符号等ASCII字符只需1个字节编码，比较节省空间。在UTF-8编码中，使用1个字节表示0-127范围内的字符，2个字节表示 128-2047 范围内的字符，3个字节表示 2048-65535 范围内的字符，4个字节表示 65536-1114111 范围内的字符。

总的来说，ASCII是最基本的字符编码方式，Unicode扩展了字符集的范围，而UTF-8则是Unicode的一种编码方式，具有可变长度编码和兼容ASCII编码的优点，因此被广泛应用于互联网和计算机系统中。

字符串

了解了字符编码，我们再来看字符串，Python中，字符串是一个不可变的序列（Sequence），用于表示一段字符序列, 采用 Unicode 编码方式，因此可以表示世界上几乎所有的字符。

#Python中的字符串可以用单引号、双引号或三引号来表示
str1 = 'Hello, world!'  # 使用单引号
str2 = "Hello, world!"  # 使用双引号
str3 = '''Hello, 
          world!'''     # 使用三引号表示多行字符串
#字符串是不可变的，也就是说，一旦定义了一个字符串，就不能再修改它的值，只能重新定义一个新的字符串。
str1 = 'Hello, world!'
str1[0] = 'h'  # 错误，字符串不可变
##Python中的字符串支持各种常见的操作，例如字符串连接、字符串切片、字符串查找、大小写转换等等。例如：
str1 = 'Hello, '
str2 = 'world!'
str3 = str1 + str2  # 字符串连接
print(str3)  # 输出：Hello, world!
str4 = 'hello, world!'
print(str4[0:5])  # 输出：hello，字符串切片
print(str4.find('world'))  # 输出：7，查找字符串中子串的位置
print(str4.upper())  # 输出：HELLO, WORLD!，将字符串转换为大写
#Python中的字符串非常灵活，可以通过各种操作来实现字符串的处理和转换。同时，Python也提供了丰富的字符串处理库，例如正则表达式库re，可以更加高效和方便地处理字符串。

列表（list）, 元祖（tuple）

python 中提供了 list 和 tuple 来表示有序集合，其区别是 list 可修改，tuple （元祖）一旦初始化就不能修改；

详细介绍如下：

list

在Python中，数组通常用列表（list）来表示。列表是一种有序的可变序列，它可以存储任意类型的元素。列表的索引从0开始，可以通过索引访问和修改元素。以下是一个示例：

#1. 创建列表
#可以使用方括号 [] 或 list() 函数创建一个新的列表
my_list = [1, 2, 3, "hello"]
another_list = list(range(5))
#2. 访问列表元素
#可以使用索引来访问列表中的元素，索引从0开始。也可以使用负数索引从列表末尾开始倒数访问元素
print(my_list[0])  # 输出 1
print(my_list[-1])  # 输出 "hello"
#3. 切片操作
##可以使用切片操作访问列表的子序列，切片操作的语法为 start:end:step
print(my_list[1:3])  # 输出 [2, 3]
print(my_list[:2])  # 输出 [1, 2]
print(my_list[::2])  # 输出 [1, 3]
#4. 修改列表
#可以使用索引来修改列表中的元素，也可以使用切片操作修改多个元素
my_list[0] = "new value"
my_list[1:3] = [4, 5]
'''5. 列表方法
Python列表提供了许多有用的方法来操作列表，例如：
- `append()` 在列表末尾添加一个元素
- `extend()` 将一个列表的元素添加到另一个列表的末尾
- `insert()` 在指定索引处插入一个元素
- `remove()` 删除列表中第一个匹配的元素
- `pop()` 删除并返回指定索引处的元素
- `index()` 返回指定元素在列表中第一次出现的索引
- `count()` 返回指定元素在列表中出现的次数
- `sort()` 对列表进行排序
- `reverse()` 将列表反转
'''
my_list.append("new element")
my_list.extend([6, 7])
my_list.insert(1, "new element at index 1")
my_list.remove("hello")
popped_element = my_list.pop(2)
index_of_element = my_list.index("new element")
count_of_element = my_list.count(2)
my_list.sort()
my_list.reverse()
#6. 复制列表
##可以使用切片操作或者 `copy()` 方法来复制一个列表
my_list_copy = my_list[:]
my_list_copy = my_list.copy()
#7.获取列表长度
#可以使用 `len()` 函数获取一个列表的长度，即其中元素的个数
print(len(my_list))  # 输出 4

tuple

在Python中，元组（tuple）是一个不可变（immutable）的序列，类似于列表（list），不同之处在于元组的元素不能被修改，添加或删除。元组可以包含任何类型的对象，包括其他元组。

可以使用圆括号 () 或者 tuple() 函数来创建一个元组。

#1. 创建：
my_tuple = (1, 2, 3, "hello")
another_tuple = tuple(range(5))
#2. 访问元组元素
#可以使用索引来访问元组中的元素，索引从0开始。也可以使用负数索引从元组末尾开始倒数访问元素。
print(my_tuple[0])  # 输出 1
print(my_tuple[-1])  # 输出 "hello"
#3. 切片操作
#可以使用切片操作访问元组的子序列，切片操作的语法为 start:end:step。
print(my_tuple[1:3])  # 输出 (2, 3)
print(my_tuple[:2])  # 输出 (1, 2)
print(my_tuple[::2])  # 输出 (1, 3)
#4. 复制元组
#由于元组是不可变的，所以不能像列表那样使用切片操作来复制一个元组。可以使用 `tuple()` 函数或者直接将一个元组赋值给另一个变量来复制一个元组，例如：
my_tuple_copy = tuple(my_tuple)
another_tuple = my_tuple
#5. 元组解包
#元组可以使用比较运算符进行比较，比较的规则是从左到右依次比较元组中的每一个元素，直到发现不相等的元素或者所有元素都比较完毕
(1, 2) < (1, 3)  # 返回 True
(1, 2) == (2, 1)  # 返回 False

条件判断

可以使用条件判断语句来根据某个条件来执行不同的代码，Python中的条件判断语句使用 if， elif， else 关键字

score = float(input("请输入分数："))
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "E"
print("你的等级是：", grade)

除了 if 语句，Python还提供了一些其他的条件语句和表达式，如 while 循环和 for 循环，以及 and、or、not 等逻辑运算符。这些都是Python编程中非常基础的知识点，需要学习掌握。

循环

python 有两种基本的循环方式， for in 和 while, 基本用法如下

#1. for in 循环示例：
my_list = [1, 2, 3, 4, 5]
for num in my_list:
    print(num)
#2. while 循环示例
n = int(input("请输入一个整数："))
factorial = 1
while n > 0:
    factorial *= n
    n -= 1
print(factorial)

除了 for 和 while 循环之外，Python 还提供了一些高级的循环控制语句，如 break、continue、else 等，这些语句能够使循环更加灵活。

for 循环怎么获取下标？

可以使用 enumerate() 函数来在 for 循环中同时获取元素和它的索引。enumerate() 函数返回一个枚举对象，其中每个元素都是一个元组，包含两个元素：索引和对应的元素值。

my_list = ["apple", "banana", "orange"]

for i, fruit in enumerate(my_list):
    print(i, fruit)

# 0 apple
# 1 banana
# 2 orange

字典 (dict)

Python 中的字典（dict）是一种无序、可变的数据类型，相当于其他语言中的 map, 用于存储键值对。

下面是一个简单的字典示例：

my_dict = {'apple': 3, 'banana': 2, 'orange': 4}
'''字典有许多常用的操作，包括：
1.  访问元素：可以通过键来访问字典中的值，例如 `my_dict['apple']` 将返回 3。
2.  修改元素：可以通过键来修改字典中的值，例如 `my_dict['banana'] = 5` 将把 `banana` 的值修改为 5。
3.  添加元素：可以使用赋值语句来添加新的键值对，例如 `my_dict['grape'] = 6` 将添加一个新的键值对 `grape: 6`。
4.  删除元素：可以使用 `del` 语句来删除键值对，例如 `del my_dict['orange']` 将删除键为 `orange` 的键值对。
5.  遍历元素：可以使用 `for` 循环来遍历字典中的键值对，例如：'''
   for key, value in my_dict.items():
    print(key, value)
#6. 获取键、值、键值对的列表：可以使用 `keys()`、`values()` 和 `items()` 方法来分别获取所有键、所有值和所有键值对的列表。例如:
  keys = my_dict.keys()
	values = my_dict.values()
	items = my_dict.items()
#注意，`keys()`、`values()` 和 `items()` 方法返回的是视图对象，而不是列表。如果需要将其转换为列表，可以使用 `list()` 函数来转换。

集合（set）

集合（set）是一种无序、可变的数据类型，用于存储一组唯一的对象，集合不允许重复元素，而且是无序的，即不支持通过索引来访问元素，集合可以用花括号 {} 或 set() 函数来创建。

#1.创建集合：
my_set = {1, 2, 3}
my_set = set([1, 2, 3])
#2.添加元素
my_set.add(4)
my_set.update([4, 5, 6])
#3.删除元素
my_set.remove(4)
my_set.discard(5)
my_set.pop()
#4.清空集合
my_set.clear()
#5.判断元素是否在集合中
if 1 in my_set:
    print('1 is in the set')
#6.求交集、并集、差集
set1 = {1, 2, 3}
set2 = {2, 3, 4}
intersection = set1 & set2 # 求交集
union = set1 | set2 # 求并集
difference = set1 - set2 # 求差集
#7.遍历集合
for item in my_set:
    print(item)

The above is the detailed content of What are the basic data types and common syntax in Python?. For more information, please follow other related articles on the PHP Chinese website!