Python基础语法

最新推荐文章于 2023-02-22 17:09:52 发布

吕树

最新推荐文章于 2023-02-22 17:09:52 发布

阅读量680

点赞数

分类专栏： Python

本文链接：https://blog.csdn.net/qq_38545819/article/details/86250151

版权

Python 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Python 中，单行注释符号为#

list02=[1,2,3,4.6,7]
list03=map(int,list02)
print(list(list03))
结果：[1, 2, 3, 4, 7]

源代码后缀： .py

解释器：pvm–python虚拟机（类似于java的jvm），编译生成一个字节码文件，.pyc文件，再把字节码文件解释成程序结果。

【先编译，再解析。】

计算机：计算—算术运算+逻辑运算

编写源代码（存在硬盘）—>编译（到内存中）—>运算（cpu）

一、变量：（python不需要声明变量类型）

1.命名规则

– 标识符：变量名，函数名，类名等统称为标识符。

1.1 Python标识符命名规则：

1.1.1. 由字母、数字、下划线组成

1.1.2. 不能以数字开头

1.1.3. 不能以关键字作为标识符 – 开发语言中用来表示特殊含义的词。

打印关键词：
import keyword
print(keyword.kwlist)

1.1.4. 标识符区分大小写

i=1
I=2
print(i)
print(I)
打印结果1    2

1.2 行业标准

1.2.1. 见名知意

1.2.2. 驼峰式命名

变量名     有多个单词组成，用_连接  stu_name
函数名     首个单词首字母小写，后面的单词首字母大写getNameTo
类名       首字母大写  Student

2. 赋值

2.1 一次给一个变量赋值

a=1
b=2

2.2.可以同时给多个变量赋值方法1

c=d=1   -- c，d指向同一个内存地址

print(id(c)) --输出变量c的内存地址
print(id(d))

如果变量值一样，则变量指向同一个内存地址。

a=b=6
c=6
print(id(a))
print(id(b))
print(id(c))

2.3. 同时多个变量赋值的方法2

    d,e,f=1,2,'newdream'
    print(d,e,f)

二、数据类型

1.number（数字）：int（整型），float（浮点型），bool（布尔型），complex（复数）
2.string（字符串）
3.list（列表）
4.tuple（元组）
5.sets（集合）
6.dictionary（字典）


不可变数据（四个）：Number（数字），String（字符串），Tuple（元组），Sets（集合）；
可变数据（两个）：List（列表）、Dictionary（字典

print(type(变量名))  ---查看变量类型

把数字数据类型：整型(int)，浮点型(float)，布尔型(bool)在计算机中的所占空间打印出来

（起始大小与cpu有关，有些为14，有些为28，随着数字位数增大，所占用空间越来越大，在内存足够的情况下无上限）

a=1
d=1234567
b=5.9
c=True
import sys
print(sys.getsizeof(a),sys.getsizeof(d),sys.getsizeof(b),sys.getsizeof(c))
输出结果为：14 16 16 14

Python 使用单引号（'）、双引号（"）、三引号（'''   
''' ）来表示字符串。其中三引号可以由多行组成，它是编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当作注释。
w1= ‘hello’ ; w2= “ hello,world! ” --python中在一行中写多条语句可以使用 ; 号隔开.
w3 =''' Every new day begins
with possibilities. '''
1. print(w1)
2. print(w2)
3. print(w3)

结果：

1. hello
2. hello，world！
3. Every new day begins
   with possibilities.

1.字符串类型

字符串切片举例:

重点：包头不包尾[a:b],只打印a到b-1，若想打印b，则应该为[a,大于b的下标]

变量名[起始下标：终止下标]  ---打印起始，不打印终止

str='Hello World!'
print(str)  输出完整字符串
print(str[0])  输出字符串中的第一个字符
print(str[2:5])  输出字符串中第三个至第五个之间的字符串（下标从2开始，到下标5结束，但不包含下标5的字符。）
print(str[-8,-1]) ---从右开始第一个下标为-1，向左依次减1。（下标从-8开始，到-1结束，不包含-1）（若要打印-1，应为[-8:]）
print(str[2:])  输出从第三个字符开始的字符串

字符串操作举例：

print(str * 2)  输出字符串两次
print(str + 'TEST')  输出连接的字符串   ---只能字符串与字符串拼接，整型不能拼。

a='adasd';b='dasdwdasdf' 
print(a+b)
print(a+'test')
输出结果为：
adasddasdwdasdf
adasdtest

字符串常用方法举例：

capitalize()将字符串第一个字符大写
lower()将整个字符串都小写
upper()将整个字符串都大写
replace('old','new'[,'count'])将字符串中的old子串替换为new，替换count次，默认全部替换

a='asdvbasd,aolddawdold'

1. print(a.capitalize())
2. print(a.lower())
3. print(a.upper())
4. print(a.replace('old','new',1))
5. print(a.replace('old','new'))

以上语句结果分别为：

1. Asdvbasd,aolddawdold
2. asdvbasd,aolddawdold
3. ASDVBASD,AOLDDAWDOLD
4. asdvbasd,anewdawdold
5. asdvbasd,anewdawdnew

split(sep):将字符串用给定的标准分割，并且以列表形式返回分割后的元素组

str1 = 'python python python'
str2 = '1,2,3,4'
str3 = '1,,2,3'
str4 = '123423664234'

print(str1.split())
print(str2.split(','))
print(str3.split(','))
print(str4.split('2'))

以上语句输出如下：

['python', 'python', 'python']
['1', '2', '3', '4']
['1', '', '2', '3']
['1', '34', '3664', '34']

字符串格式化：

s='hello'
print('s=%s'%s)
print('s='+s)
print('%s'%s)
print('s=%s')

输出结果为：

s=hello
s=hello
hello
s=%s

name='luoman'
age=18
phone='13677484764'
print('%s今年%d岁电话号码是%s' %(name,age,phone))
结果：luoman今年18岁电话号码是13677484764
print('%-10s今年%d岁电话号码是%s' %(name,age,phone))
结果是：luoman    今年18岁电话号码是13677484764(name一项从左开始占10位，不足的用空格补，右对齐用+)
score=66.66666666666
print('%s的考试成绩是%8.2f'%(name,score)) ---向右对齐，八位，不足的空格补，四舍五入取两位小数
结果是：luoman的考试成绩是   66.67 
print('%s的考试成绩是%08.2f'%(name,score)) ---同上，不足的位用0补。注意只有右对齐可以用0补，左对齐0补无意义。
结果：luoman的考试成绩是00066.67

name='luoman'
print('%s今年18岁'%name)
结果：luoman今年18岁

%d,%i 带符号的十进制数(%i可以将八进制，十六进制数转为十进制)
%o 不带符号的八进制
%u 不带符号的十进制
%x 不带符号的十六进制(小写)
%X 不带符号的十六进制(大写)
%e 科学计数法表示浮点数(小写)
%E 科学计数法表示浮点数(大写)
%f,%F 十进制浮点数
%g 如果指数大于-4或者小于精度值则和e相同,其它情况和f相同
%G 如果指数大于-4或者小于精度值则和E相同,其它情况和F相同
%C 单字符（接收整数，或者一个字符的字符串）
%r 字符串（使用repr转换）
%s 字符串（使用str转换）

2.列表类型：

List（列表）是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符，数字，字符串

甚至可以包含列表（所谓嵌套）。

列表用[ ]标识，是python最通用的复合数据类型。

列表中值的分割也可以用到变量[头下标:尾下标]，就可以截取相应的列表，从左到右索引默认0开始的，从右到左索引默认-1开始，下标可以为空表示取到头或尾。

加号（+）是列表连接运算符，星号（*）是重复操作。

举例：

list=['asdc',123,2.89,'daw',70.2] --定义列表list
tinylist=[123,5,6,4,8] --定义列表tinylist
1. print(list)  --输出完整列表list
2. print(list[0]) --输出列表的第一个元素
3. print(list[1:3]) --输出列表第2至第3个元素  ？？？？
4. print(list[2:]) --输出从第3个开始到末所有元素
5. print(list*2)--输出列表两次
6. print(list[0]*2)--输出list第一个元素两次，没有间隔号
7. print(list[1:3]*2)--输出列表list第2到3个元素两次
8. print(list+tinylist+list)---打印组合的列表

结果为：

1. ['asdc', 123, 2.89, 'daw', 70.2]
2. asdc
3. [123, 2.89]
4. [2.89, 'daw', 70.2]
5. ['asdc', 123, 2.89, 'daw', 70.2, 'asdc', 123, 2.89, 'daw', 70.2]
6. asdcasdc
7. [123, 2.89, 123, 2.89]
8. ['asdc', 123, 2.89, 'daw', 70.2, 123, 5, 6, 4, 8, 'asdc', 123, 2.89, 'daw', 70.2]

列表常用函数：

列表常用操作方法：
L=[]   ---定义列表L，值为空
L.append(var) #追加元素
list01.append('java')

L.insert(index,var) #在指定位置插入元素
list01.insert(2,'哈哈')

L.pop(var) #返回最后一个元素，并从list中删除之，打印这个方法会有返回值

lis=['dasdas','dasd','dasdddwdsadwds']
1. print(lis.pop())
2. print(lis)
3. print(lis.pop(1))
4. print(lis)
结果为：
1. dasdddwdsadwds
2. ['dasdas', 'dasd']
3. dasd
4. ['dasdas']

注意，打印函数和打印结果是不一样的，若果函数有返回值，打印函数才会有输出。

L.remove(var) #删除第一次出现的该元素
print(list01.remove('hello'))


L.count(var) #该元素在列表中出现的个数
print(list01.count('刘诗琴'))

L.index(var) #该元素的位置,无则抛异常
print(list01.index('hello'))


L.extend(list) #追加list，即合并list到L上

L.sort() #排序 --升序
等价于：
sorted(list) 


print(sorted(list02, reverse=True))   --降序

L.reverse() #反转

list=[123]
list.append('哈哈哈')
print(list)

结果为：

[123, '哈哈哈']
备注：一次只能追加一个值，多个值要分多次追加。

列表的复制：

L1 = L #L1为L的别名，用C来说就是指针地址相同，对L1操作即对L操作。函数参数就是这样传递的。【只是别名】
L1 = L[:] #L1为L的克隆，即另一个拷贝。【地址不一样了】
print(id(L))  ---打印地址
也可以拷贝一部分：
L1=L[2:3]

注意：数字

a=1  
b=a   
a=2+1
print(a,b)
结果是：3
        1

对应前面提过的可变类型（改变一个另一个也会变）和不可变类型（改变一个，另一个不会变）

不可变数据（四个）：Number（数字），String（字符串），Tuple（元组），Sets（集合）；

可变数据（两个）：List（列表）、Dictionary（字典）

3. 元组（tuple）：

元组是类似于List（列表）的另一个数据类型。

元组用 ()标识，内部元素用逗号隔开。但是元素不能二次赋值，相当于只读列表。

构造包含 0个或1个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = () # 空元组

tup2 = (20,) #一个元素，需要在元素后添加逗号 #可以不添加，号

注意事项：

1、元组也可以被索引和切片，方法与列表一样；
2、与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以
组合和复制，运算后会生成一个新的元组；
3、元组可以使用之前列表中的count()、index()方法，其余的方法不行；
4、因为元组不可变，所以代码更安全。如果可能，能用元组代替列表就尽量用元组。

4.集合（set）

1. 集合（set）是一个无序不重复元素的序列。
2. 基本功能是进行成员关系测试和删除重复元素。
3. 可以使用大括号{}或者set()函数创建集合，注意：创建一个空集合必须用 set()而不是 { }，因为 { } 是用来创建一个空字典。
举例：
ser01={'new','dream',66} #普通集合
set02= set('newdream') 
print(set02)
结果：{'w', 'n', 'm', 'r', 'e', 'a', 'd'}
#把字符串强制转换为集合，有相同的字符e，只保留一个。

去重：

set02={'a','a','c','d','e'}
print(set02)
结果：{'a', 'e', 'c', 'd'}

无序：

set01={'a','b','c','d','e'}

1. print(set01)
2. print(set01)
3. print(set01)
4. print(set01,set01)

结果：
1. {'b', 'e', 'c', 'a', 'd'}
2. {'b', 'e', 'c', 'a', 'd'}
3. {'b', 'e', 'c', 'a', 'd'}
4. {'b', 'e', 'c', 'a', 'd'} {'b', 'e', 'c', 'a', 'd'}

因为是一次执行以上所有输出操作，所以顺序相同。

同一次执行程序，顺序是一致的，不同次，顺序会随机无序。

集合运算：
a = set('newdream66')
b = set('news90')
print(a - b) # a和b的差集 即打印a中存在，但b中不存在的元素
print(b - a) # b和a的差集 即打印b中存在，但a中不存在的元素
print(b | a) # a和b的并集 即打印a和b中不重复的所有元素
print(a&b) # a和b的交集 即打印a和b中都存在的元素
print(a ^ b) # a和b中不同时存在的元素,交集的补集

set1={'aa','bb','cc','dd','ee'}
set2={'ii','kk','cc','ww','ee'}
print(set1-set2) 
结果：{'aa', 'bb', 'dd'}
print(set1|set2)
结果:{'ee', 'cc', 'bb', 'ww', 'ii', 'kk', 'aa', 'dd'}
print(set1&set2)
结果:{'ee', 'cc'}
prit(set1^set2)
结果：{'dd', 'ii', 'bb', 'aa', 'ww', 'kk'}

判断某个元素是否在集合中：结果只有Ture和False

成员测试： 可以用 in 关键字判定元素是否在集合内。
print('aa'in set1)
结果：True

5.字典（dictionary）–以键值对方式存在

键值不允许重复。

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。

列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

定义字典：

一般形式：
dict01={'name':'zmy','age':18,'score':99.99}
工厂方法dict():
dict02=dict((['name','zmy'],['age',18],['score',88.88]))
关键字参数：
dict03=dict(name='zmy',age=18,score=88.88)
print(dict01)
结果：{'name': 'zmy', 'age': 18, 'score': 99.99}
print(dict02)
结果：{'name': 'zmy', 'age': 18, 'score': 88.88}
print(dict03)
结果：{'name': 'zmy', 'age': 18, 'score': 88.88}

内键方法：fromkeys(S [ , v])) ，即将S里的元素作为键，v作为所有键的值，即字典中的元素具有相同的值， v 的默认值为 None。

list1=['a','b','c']
dict04=dict.fromkeys(list1,'python')
print(dict04)
结果：{'a': 'python', 'b': 'python', 'c': 'python'}

dict05={}.fromkeys(('x','y','c'),1)
print(dict05)
结果：{'x': 1, 'y': 1, 'c': 1}

更新或修改词典：

dict01['height']=160  --字典中没有，增加元素到字典
print(dict01)
dict01['age']=20 --字典中有，更新值
print(dice01)

删除字典元素：

delete dict01['height']

删除字典dict01：

delete dict01

字典常用方法：

1、adict.keys() 返回一个包含字典所有KEY的列表；
2、adict.values() 返回一个包含字典所有value的列表；
3、adict.clear() 删除字典中的所有项或元素；
4、adict.get(key, default = None) 返回字典中key对应的值，若key不存
在字典中，则返回default的值（default默认为None）；
5、adict.pop(key[,default]) 和get方法相似。如果字典中存在key，删除
并返回key对应的vuale；如果key不存在，且没有给出default的值，则引发
keyerror异常；
6、adict.update(bdict) 将字典bdict的键值对添加到字典adict中，无则添加，有则覆盖

获取字典里所有key值：
print(dict01.keys())
结果：dict_keys(['name', 'age', 'score'])


获取字典里所有value值：
print(dict01.values())
结果：dict_values(['zmy', 18, 99.99])


删除字典中的所有项或元素:
dict01.clear()

根据key获得value
print(dict01.get('age'))  --键值存在
print(dict01.get('height')) --键值不存在，返回None


print(dict01.pop('height')) ---键值不存在，抛出异常



dict05={'x':1,'y':2}
dict01.update(dict05) --把字典dict05加到dict01中，无则添加，有则覆盖。
print(dict01)
结果：{'name': 'zmy', 'age': 18, 'score': 99.99, 'x': 1, 'y': 2}

6. 数据类型转换

程序中经常会遇到要将数据类型进行转换的情况（如：在一个表达式中存在不同类型的操作数时）

数据类型转换有两种情况：

自动类型转换【隐式类型转换】：(由低精度向高精度转换)

a=1
b=2.1
print(a+b)
结果：3.1
print(1.2+True)
结果：2.2
c=True
print(a+b+c)
结果：4.1

强制类型转换【显式类型转换】：

如果被转换的值的数据类型大于其目标类型，将会丢失部分信息。强制类型转换只需要将数据类型作为函数名即可。

常用的数据类型转换：
int(x [,base])   将x转换为一个整数
float(x)       将x转换到一个浮点数
str(x)                        将对象 x 转换为字符串--给人看
repr(x)    将对象转换为表达式字符串--和str类似，更有利于机器阅读
eval(str)  用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)   将序列 s 转换为一个元组
list(s)    将序列 s 转换为一个列表
chr(x)    将一个整数转换为一个字符
unichr(x) 【python2有，python3没有】 将一个整数转换为Unicode字符
ord(x)    将一个字符转换为它的整数值
dict(d)    创建一个字典。d必须是一个序列(key,value)元组

print(int(a+b))

d = str(['a','b'])    # 把d变量转成字符串
print(d)
print(type(d))

e= repr(['a','b']) --更利于机器理解
print(e)
print(type(e))

# eval
str1 = '3+4'
print(str1)
结果：3+4
print(eval(str1))
结果：7

三.序列：

Python 序列操作：

序列包含：字符串、列表、元组。

序列的两个特征是“索引”和“切片”，

索引：根据Index获取特定元素；

切片：获取序列片段。

常见序列操作：
list01=[1,2,3,4,5,6]

len()：求序列的长度  前后各两个下划线
print(list01.__len__())
或者print(len(list01)
结果：6
+： 连接两个序列
*：重复序列元素
in：判断元素是否在序列中
print('hello' in list01)
结果：False
max()：          返回序列最大值 
print(max(list01)
结果：6
min()：          返回序列最小值
print(min(list01))
结果：1

四.输入输出函数

input() 输入的全是字符串类型
a=input('请输入第一个数：')
b=input('请输入第二个数：')
c=a+b ---字符串拼接
print(a,b,c)
print(type(a))
结果：
请输入第一个数：5
请输入第二个数：5
5 5 55
<class 'str'>
所以如果计算就要类型转换，比如：
a=int(input('请输入第一个数：'))

输出语句，进行格式化输出

print('hello',end='')
print('world')
结果：helloworld
print('hello',end='>>>')
print('world')
结果:hello>>>world

format:

print('{}今年是{}岁'.format('吕树',18))
结果：吕树今年是18岁
print('{1}和{0}是同一个班级'.format('吕树','聂廷'))    ---数字0和1是format函数中字符串的下标，吕树是0号位置，聂廷是1号位置。
结果：聂廷和吕树是同一个班级。
print('{name1}和{name2}是同一个班级'.format(name1='叶凡',name2='石昊'))
结果：叶凡和石昊是同一个班级

五、运算符与表达式

运算符是通过一定的运算规则操作一个或多个操作数，并生成结果的特定符号

运算符和操作数的有效组合称为表达式。

Python提供了一系列丰富的运算符，包括：
Ø算术运算符
Ø赋值运算符
Ø关系运算符
Ø逻辑运算符
Ø位运算符
Ø三元运算符
Ø身份运算符
Ø成员运算符

1.算术运算符

算术运算符主要⽤用于数学计算，⼀一般使⽤用数值作为操作数。

运算符   说 明
+       加法:a+b
-       减法:a-b
*       乘法:a*b
/       除法:a/b
%       取模:a%b
//      整除:a//b
**      幂: a**3

print(7/3)  --除
print(7//3)  --整除
结果：
2.3333333333333335
2

2.赋值运算符【从右向左运算】

= 在程序中是赋值运算符,其作⽤用是获取右边的值,赋给左边；

右边可以是任何有结果的表达式,常量量或者变量；

对于基本数据类型赋值很直接,是将实际的值复制一份赋给接收的变量量存储,对这个值的任何后续修改都不不会影响其他变量，

对于引⽤用数据类型的赋值则不不同,由于引⽤用数据类型的变量量实际保存的是一个指向实际值的地址,所以使用=的结果只是将地址交给接收的变量,让这个变量也引⽤用这个空间,如果这个空间的值被修改,所有引⽤用这块空间的变量都会受影响。

运算符       说 明
=           赋值:a = 1，a = b
+=、-=      a=a+b可以写成a+=b、a=a-b可以写成a-=b
*=、/=      a=a*b可以写成a*=b、a=a/b可以写成a/=b
%=          a=a%b可以写成a%=b
//=         a=a//b可以写成a//=b

3.关系运算符

可以测试两个操作数之间的关系（但不不会改变操作数的值），关系表达式的结果为：

boolean型： true/false。

运算符  说 明
==    检查两个数的相等性
!=    检查两个数的不不等性
>     检查左边的值是否⼤大于右边的值
<     检查左边的值是否⼩小于右边的值
>=    检查左边的值是否⼤大于或等于右边的值
<=    检查左边的值是否⼩小于或等于右边的值

4.逻辑运算符

逻辑运算符与bool型操作数一起使⽤用

运算符     说 明
not     逻辑非,一元运算符,将某bool结果取反
and      逻辑与,两边的bool结果为true则表达式结果为True按照短路方式求值,当and左边的结为false时,整个表达式的结果必定为false,所以不再执行右边的运算
or     逻辑或,两边的bool结果任意一边为true，则表达式结果true。按照短路路⽅方式求值,当or左边的结果为true时,整个表达式的结果必定为true,所以不再执行右边的运算

对于逻辑运算来说，非0即1
print(not 5)
结果：False
print(not 0)
结果：True

print(7>5 and 5>9)
结果：False
print(3 and True)
结果：True
print(7>5 and not 5>9)
结果：True
print(3 and 4)   ---没有true或者false出现，会打印最后一个。
结果：4


print(not 5>7)
结果：True

print(True or 3)
结果：True
print(3 or True)
结果：3
print(0 or False)
结果：False
print(1 or False)   ---非0即1，只要or左边是true，就不看右边了》短路运算。
结果：1
print(3 or False)   ---把3当成，非0就是真
结果：3

print(9>7 or 5>7)
结果：True
print(not 9>7 or 10>7)
结果：True
print(not (9>7 or 10>7))
结果：False
print(not 9>7 or 5>7)
结果：False

5.位运算符

# 按位运算符是把数字看作二进制来进行计算的。即一般情况下，先把其它进制的数据转成二进制，再依次对每位上的数进行位运算。
& 按位与
print(10 & 5)  # 结果：0   同位为1时，结果才为1
| 按位或
print(10 | 5)  # 结果：15   同位有1时，结果为1，同时为0，结果才为0
^  异或    不同为1  相同为0
print(10 ^ 5)  # 结果：15
~ 反转  -(x)-1
print(~2)  结果：-3
print(~(-3))
<<  左移      5 << 3  原来的数*2^n
print(5<<3) # 结果：40
>> 右移               原来的数//2^n
print(24>>3)   结果：3

6.三元运算符(条件运算符)，根据判定条件执行语句

# .... if 条件判断  else....
print('结果为真' if 3<5 else '结果为假' )
# in 判断是否是序列内
# is 判断是否是同一个对象
c =1
d =1
print(c is d) 结果：True

六.分支结构：

分支 : if ..else..   if ...elif...elif..else

if 表达式:
    语句块
else:
    语句块

score=70
if score <60:
    print("该同学考试不及格")
elif score>=60 and score <=80:
    print("该同学成绩为中等")
elif score>80 and score<=90:
    print("该同学成绩为良好")
elif score>90 and score<=100:
    print("该同学成绩为优秀")
else:
    print("该同学的成绩无效")

七.循环

八.辅助语句

吕树

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python基础语法

Python 中，单行注释符号为#源代码后缀： .py解释器：pvm–python虚拟机（类似于java的jvm），编译生成一个字节码文件，.pyc文件，再把字节码文件解释成程序结果。【先编译，再解析。】计算机：计算—算术运算+逻辑运算编写源代码（存在硬盘）—&amp;amp;gt;编译（到内存中）—&amp;amp;gt;运算（cpu）一、变量：（python不需要声明变量类型）1.命名规则– 标识符：变量名，...
复制链接

扫一扫