【Python】基础语法

布丁椰奶冻

已于 2024-07-12 20:06:15 修改

阅读量856

点赞数 16

文章标签：开发语言 python

于 2024-07-12 19:35:11 首次发布

本文链接：https://blog.csdn.net/m0_67830223/article/details/140327982

版权

一、思考if __name__==”__main__”的意思和作用

1. 先执行comparenumber.py

六、集合数据结构的创建和使用，思考集合与列表和字典的异同

一、思考if name==”main”的意思和作用

1. 先执行comparenumber.py

通过debug发现：if语句_name_ == “_main_”条件成立

运行结果如下：

2. 再看test.py

通过debug发现：_name_ == “comparenumber”

此时comparenumber.py中if语句_name_ == “_main_”条件不成立

结果如下：

3. _name_的意思

只要创建了一个模块（一个.py文件），这个模块就有一个内置属性_name_生成，当直接执行该模块的时候，_name_ == ”_main_”；但如果该模块import到其他模块中，则该模块中_name_ 的值为模块文件名。

通过上面两个例子可以得出的结论是：如果模块是被直接运行的，则代码块_name_ == ”_main_”被运行，如果模块被import，则if _name_ == ”_main_”之下的代码块不被运行。

4. _name_的作用

由于_main_在python中可以作为函数的入口，而实际工程常用if _name_ == ‘_main_’来表示整个工程开始运行的入口。此外，如果不想让功能块的某个部分被其他模块调用，可以把这个部分写在if语句中，只有_name_ == ‘_main_’的时候才能执行。

二、重要语法“tab”的作用

1. test01

x = 1
if x == 1:
    print("x=", x)
else:
    print("x=", x)
    x = x + 1
print("x=", x)

分析：if和else不在一个逻辑层，故条件成立执行if语句之后直接打印结果，出来不会进入到else中也就不会执行x = x + 1指令，再次打印结果。

2. test02

x = 1
if x == 1:
    print("x=", x)
else:
    print("x=", x)
x = x + 1
print("x=", x)

分析：x = x + 1 与 x = 1 属于一个逻辑层，无论是执行if还是else出来之后，x = x + 1都会被执行，所以第二个打印结果x = 2。

物理行：代码编辑器显示的代码，每一行是物理行。

逻辑行：python解释器对语句的解释，每一条语句是一个逻辑行。

Tab缩进是针对逻辑行的，一个tab是四个空格。

‘：’标记一个新的逻辑层。

三、元组数据结构的创建和使用

思考当创建元组时单个元素的元组没有加上逗号会发生什么？

1. 创建元组

item = ('cat', -6, (1, 2))
print(item)
print(type(item))
print(item[0], item[1], item[2])
print('-----------------------------------')

item = ('cat')
print(item)
print(type(item))
print(item[0])
print('-----------------------------------')

item = ('cat',)
print(item)
print(type(item))
print(item[0])
print('-----------------------------------')

item = ()
print(item)
print(type(item))

运行结果如下：

元组创建很简单，只需要在括号中添加元素并且用逗号隔开即可，但如果只有一个元素且没加逗号，由于python解释器是把（‘str’）当成一个算术表达式来处理，它的结果是一个str型对象，这样会产生歧义，所以为了和只有单个元素的元组区分，python规定要在元素后面加上一个逗号，例如 x = (‘str’,)。

2. 访问元组的元素

fruit = ('apple', 'banana', 'grape', 'orange')
print(fruit[-1])
print(fruit[-2])
fruit1 = fruit[1:3]  # 切片，元素2--3，不包括4
fruit2 = fruit[0:-2]  # 切片，元素1--倒数第二个，不包括倒数第二
fruit3 = fruit[2:-2]  # 切片，元素3--倒数第二个，不包括倒数第二
print(fruit1)
print(fruit2)
print(fruit3)

fruit1 = ('apple', 'banana')
fruit2 = ('grape', 'orange')
fruit = (fruit1, fruit2)
print(fruit)
print('fruit[0][1] =', fruit[0][1])  # 访问第一个元组中的第2个元素
print('fruit[1][1] =', fruit[1][1])  # 访问第二个元组中的第2个元素
print('fruit[1][2] =', fruit[1][2])  # 访问第二个元组中的第3个元素，索引越界，报错

运行结果如下：

元组与字符串类似，下标索引从0开始，最后一个元素下标默认为-1

3. 操作元组

t1 = (1, 'two', 3)
t2 = (t1, 'four')

print(t1 + t2)  # 连接
print((t1 + t2)[3])  # 索引 下标3
print((t1 + t2)[2:5])   # 分片 下标2--4

t3 = ('five',)
print(t1 + t2 + t3)

运行结果如下：

可以看到元组相加会把元素连接在一起形成新元组。

四、列表数据结构的创建和使用

1. 创建列表

numbers1 = [7, -7, 2, 3, 2]
print(numbers1)
print(type(numbers1))

numbers2 = [7]
print(numbers2)
print(type(numbers2))

numbers3 = []
print(numbers3)
print(type(numbers3))

执行结果：

2. 使用列表

numbers = [7, -7, 2, 3, 2]
print(numbers)
print(numbers + numbers)
print(numbers * 2)

lst = [3, (1,), 'dog', 'cat']
print(lst[0])
print(lst[1])
print(lst[2])
print(lst[1:3])
print(lst[2:])  # 下标为2到最后
print(lst[-3:])  # -3到最后
print(lst[:-3])  # 开始到-3 不包括-3

for i in range(len(lst)):  # 遍历列表lst
    print(lst[i], end=' ')

五、字典数据结构的创建和使用

1. 字典的创建、添加、删除和修改

dict = {'a':'apple', 'b' :'banana', 'g':'grape', 'o':'orange'}  # 创建字典
print(dict)
dict['w'] = 'watermelon'  # 添加字典元素
print(dict)
del(dict['a'])  # 删除字典中键为’a'的元素
print(dict)
dict['g'] = 'grapefruit'  # 修改字典中键为‘g'的值
print(dict)

运行结果如下：

2. 字典函数的使用

dict = {'a':'apple', 'b' :'banana', 'c':'grape', 'd':'orange'}
# 输出key的列表
print(dict.keys())
# 输出values的列表
print(dict.values())
# 获取字典中的元素
print(dict.get('c'))
print(dict.get('e'))
# 字典的更新
dict1 = {'a':'apple', 'b':'banana'}
print(dict1)
dict2 = {'c':'grape', 'd':'orange'}
print(dict2)
dict1.update(dict2)
print(dict1)

运行结果如下：

六、集合数据结构的创建和使用，思考集合与列表和字典的异同

1. 创建集合

basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
print(basket)
print(type(basket))
fruit = set(basket)
print(fruit)
print(type(fruit))

print('orange' in fruit )
print('crabgrass' in fruit )

运行结果如下：

2. 集合运算

a = set('abracadabra')
b = set('alacazam')
print(a)
print(b)

# 差运算
print(a - b)

# 或运算
print(a | b)

#并运算
print(a & b)

# 异或运算
print(a ^ b)

运行结果如下：

七、小结

1. Python中的注释

Python中单行注释以 # 开头，多行注释可以用多个 # 号，还有 ''' 和 """。

2. 行与缩进

Python使用缩进来表示代码块，不需要使用大括号 {} 。

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。

3. 变量

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。

在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

4. 等号

等号（=）用来给变量赋值。

等号（=）运算符左边是一个变量名。

等号（=）运算符右边是存储在变量中的值。

5. 基本数据类型

（1）Python3 中有5个标准数据类型：String（字符串）、Number（数字）、List容器、Bool（布尔）、None(空值)。

字符串（String）

字符串就是表示一串字符，字符可以是中文，英文或者数字，或者混合的文本。

Python中的字符串用英文状态下的单引号 ’或双引号 " 括起来。

数字(Number)

数字类型分为整数型和浮点型。

整型：像11、60这种整数；浮点型：像3.14、2.50这种带小数的。

（2）容器：用来存放数据的，是一种把多个元素组织在一起的数据结构，容器中的元素可以逐个地迭代获取，可以用in, not in关键字判断元素是否包含在容器中。可分为List（列表）、Tuple（元组）、Set（集合）、Dictionary（字典）四种。

6. 可变数据与不可变数据

String（字符串）、Number（数字）、Tuple（元组）、Bool（布尔）、None(空值)为不可变数据；List（列表）、Dictionary（字典）、Set（集合）为可变数据。

7. 列表、元组、集合和字典

（1）列表（list）

列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号[ ]之间、用逗号分隔开的元素列表。

（2）元组（Tuple）

元组的元素不能修改。元组写在小括号()里，元素之间用逗号隔开。

元组是不可变类型，不支持增删改，只能查询。

元组中只包含一个元素时，需要在元素后面添加逗号（,）否则括号会被当作运算符使用。

（3）集合（Set）

集合（set）是一个无序的不重复元素序列。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用set() 而不是 { } ，因为 { } 是用来创建一个空字典。

（4）字典(Dictionary)

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号：分割，每个对之间用逗号(,)分割，整个字典包括在花括号 { } 中 ,键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字。

布丁椰奶冻

关注

16
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫