Rumah >pembangunan bahagian belakang >Tutorial Python >Apakah jenis data asas dan sintaks biasa dalam Python?
Dalam Python, integer (integer) ialah jenis data terbina dalam yang digunakan untuk mewakili nilai integer. Jenis integer dalam Python boleh mewakili integer dari sebarang saiz tanpa mengambil kira had panjang perkataan komputer. Ini kerana Python secara automatik melaraskan bilangan bit dalam jenis integer mengikut keperluan supaya integer dari sebarang saiz boleh disimpan.
Berikut ialah beberapa contoh integer:
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
Dalam Python, untuk perwakilan nombor besar, anda boleh terus menggunakan integer atau integer panjang tanpa menggunakan notasi saintifik .
Dalam Python 2.x, saiz integer adalah terhad, nilai maksimum ialah 2^31 - 1, jika anda perlu mewakili integer yang lebih besar, anda boleh menggunakan integer panjang. Integer panjang tidak mempunyai had saiz apabila diwakili, kerana ia boleh melaraskan saiznya secara automatik agar sesuai dengan ketepatan yang diperlukan.. Literal integer boleh ditandakan sebagai panjang menggunakan akhiran "L", contohnya: 12345678901234567890L.
Dalam Python 3.x, integer tidak lagi mempunyai sekatan saiz nilai dan boleh secara langsung mewakili integer yang sangat besar tanpa menggunakan integer yang panjang. Dalam Python 3.x, integer panjang telah disepadukan ke dalam integer biasa, jadi tiada penanda atau sintaks tambahan diperlukan apabila mewakili nombor yang besar.
Sebagai contoh, dalam Python integer yang sangat besar boleh diwakili seperti ini:
x = 123456789012345678901234567890
Apabila bercakap tentang nilai null dalam Python, kita boleh lihat ialah pemegang tempat digunakan untuk mewakili tiada nilai atau nilai nol.
Dalam Python, nilai nol diwakili oleh objek terbina dalam None
, yang istimewa dan boleh digunakan sebagai pemegang tempat untuk sebarang jenis. Apabila pembolehubah tidak diberikan nilai atau nilai pulangan fungsi memerlukan pemegang tempat, kami biasanya menggunakan None
untuk mewakili nilai nol. Berikut ialah contoh mudah yang menunjukkan cara menggunakan 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")
Dalam contoh di atas, kami mula-mula menetapkan pembolehubah x
dan z
kepada None
. Kemudian, kami menggunakan operator is
untuk menyemak sama ada pembolehubah x
ialah None
. Oleh kerana x
sememangnya None
, syarat if x is None
ditetapkan dan "x is None"
dicetak. Sebaliknya, jika pembolehubah x
mengandungi sebarang nilai lain (seperti nilai integer), syarat itu tidak akan berlaku.
Perlu diambil perhatian bahawa None
berbeza daripada rentetan kosong atau senarai kosong. Rentetan kosong bermakna tiada aksara, dan senarai kosong bermakna tiada unsur. Sebaliknya, None
ialah objek, yang tidak mewakili nilai atau nilai nol. Oleh itu, semasa menulis kod Python, None
harus difahami dan digunakan dengan betul untuk mengelakkan kekeliruan dan ralat.
Dalam Python, titik terapung ialah jenis data terbina dalam yang digunakan untuk mewakili nombor nyata. Tidak seperti jenis integer, nombor titik terapung ialah anggaran, bukan nilai tepat. Ini kerana Python menggunakan format titik terapung berketepatan dua untuk mewakili nombor titik terapung Format ini boleh mewakili nombor yang sangat besar dan sangat kecil, tetapi boleh menyebabkan beberapa isu ketepatan disebabkan oleh ralat anggaran dan pembundaran. Oleh itu, apabila bekerja dengan nombor titik terapung, anda perlu sedar tentang ralat pembundaran dan isu ketepatan.
Dalam Python, anda boleh menggunakan titik perpuluhan untuk mewakili nombor titik terapung, atau anda boleh menggunakan tatatanda saintifik. Sebagai contoh, berikut ialah beberapa contoh nombor titik terapung:
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
Dalam contoh di atas, kami menggunakan fungsi round()
untuk membundarkan nombor titik terapung kepada dua tempat perpuluhan. Kemudian, kami mencetak hasilnya dan mendapatkan 0.6 yang dijangkakan.
Terdapat tiga operator logik dalam Python: operasi DAN (and
), operasi ATAU (or
) dan operasi BUKAN (not
) . Operator logik ini boleh digunakan pada nilai jenis Boolean (Benar atau Salah) serta jenis nilai lain.
digunakan seperti berikut:
#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`),可以用于各种逻辑操作中。
Oleh kerana komputer dicipta oleh orang asing, mereka hanya boleh mengenali huruf besar dan kecil Inggeris, nombor dan beberapa simbol pada mulanya, yang telah melalui ASCII
Dilaksanakan dengan pengekodan, seperti yang ditunjukkan dalam rajah di bawah, pengekodan B ialah 66, dan pengekodan 1 ialah 49;
Dengan perkembangan komputer dan Internet, ia adalah digunakan di semua negara di seluruh dunia, pengekodan ASCII
jelas tidak mencukupi untuk mewakili aksara Cina dan aksara lain, semasa proses ini, China merumuskan GB2312
, dan Korea Selatan merumuskan format pengekodannya sendiri seperti Euc-kr
mengelakkan konflik, set aksara Unicode
kemudiannya dilahirkan, yang menyatukan semua pengekodan dan menyelesaikan Ini menyelesaikan masalah kod bercelaru yang disebabkan oleh percanggahan pengekodan, dan kemudiannya memperoleh pengekodan "pengekodan panjang pembolehubah" UTF-8
yang lebih kos efektif.
Mari kita selesaikan perbezaan antara ASCII
, Unicode
, UTF-8
:
ASCII、Unicode
dan UTF-8
ialah kedua-dua standard pengekodan aksara, digunakan untuk menukar aksara kepada Nombor binari untuk pemprosesan komputer. Perbezaan utama antara mereka ialah kaedah pengekodan dan set aksara yang boleh diwakili.
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,可以更加高效和方便地处理字符串。
python 中提供了 list 和 tuple 来表示有序集合,其区别是 list 可修改,tuple (元祖)一旦初始化就不能修改;
详细介绍如下:
在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
在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
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()
函数来创建。
#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)
Atas ialah kandungan terperinci Apakah jenis data asas dan sintaks biasa dalam Python?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!