目录
一、思考if __name__==”__main__”的意思和作用
一、思考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 对用冒号：分割，每个对之间用逗号(,)分割，整个字典包括在花括号 { } 中 ,键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字。
标签：Python,元素,基础,元组,语法,item,fruit,print,字典 From： https://blog.csdn.net/m0_67830223/article/details/140327982