Python基础语法---学习记录3.15（持续更新）
Python基础语法---学习记录3.15（持续更新）
- 0. 前言
- 1. 词法分析
-
- 1.1 行结构
-
- 1.1.1 编码声明
- 1.2 其它标记符
-
- 1.2.1 关键字和标识符
- 2. 数据类型
-
- 2.1 标准数据结构类型
-
- 2.1.1 Number
- 2.1.2 String
- 2.1.3 List
- 2.1.4 Tuple
- 2.1.5 Dictionary
- 3. 运算符
-
- 3.1 算术运算符
- 3.2 比较运算符
- 3.3 赋值运算符
- 3.4 位运算符
- 3.5 逻辑运算符
- 3.6 成员运算符
- 3.7 身份运算符
- 3.8 运算符的优先级
- 4. 条件语句
- 5. 循环语句
-
- 5.1 while循环
- 5.2 for循环
- 5.3 循环嵌套
0. 前言
Python官方文档：https://www.python.org/
1. 词法分析
1.1 行结构
一个Python程序可以分为很多逻辑行。
1.1.1 编码声明
如果一条注释位于Python脚本文件的第一行或者第二行，并且符合正则规范coding[=:]\s*([-\w.]+)， 这条注释会被作为编码声明来处理。推荐的编码声明如下：
# -*- coding: -*-
# vim:fileencoding=如果没有编码声明，则默认编码为UTF-8.
1.2 其它标记符
1.2.1 关键字和标识符
以下标识符被作为语言的关键字，不可作为普通标识符，关键字的拼写必须正确，如下所示：
False class finally is return
None continue for lambda try
True def from nonlocal while
and del global not with
as elif if or yield
assert else import pass
break except in raise
在Python中以_开头的标识符具有特殊含义，例如：
# 以_开头的标识符，如_width，表示不能直接访问类的属性，无法通过from ... import ... 的方式导入。
# 以__开头的标识符，如__add，表示类的私有成员。
# 以__开头和结尾的标识符，如__init__，属于专用标识符
2. 数据类型
2.1 标准数据结构类型
Python常用的数据类型为：
不可变数据：Number（数字）、String（字符串）、Tuple（元组）
可变数据：Set（集合）、Dictionary（字典）List（列表）
2.1.1 Number
Number由数值文字创建，并由算术运算符和算术内置函数作为结果返回。当指定一个值时，Number对象就会被创建。
Python支持四种不同的数字类型：int（整数）、bool（布尔值）、float（浮点数）、complex（复数）
2.1.2 String
字符串是由数字、字母、下划线组成的一串字符，用引号表示。字符串的索引也是通过下标序号实现的，可以使用**[头下标：尾下标]**（从左到右索引下标序号默认从0开始，从右到左索引默认从-1开始；索引得到的值只包括头下标不包括尾下标），例如：
var1 = 'hello,world!'
print(var1[2:8])
# 结果显示
llo,wo
print(var1[-10:-1])
# 结果显示
llo,world
字符串索引的一些其他用法，例如：
var1 = 'hello,world!'
print(var1)
print(var1[3:]) # 输出从第三个字符开始后所有的字符串
print(var1 * 2) #输出字符串两次
print(var1 + '888_an') # 输出连接的字符串
print(var1[1:8:2]) # [头下标：尾下标：步长]
# 结果显示
hello,world!
lo,world!
hello,world!hello,world!
hello,world!888_an
el,o
2.1.3 List
列表是Python中常用的数据类型，支持字符、数字、字符串以及列表，是复合数据类型用[]表示。
列表的索引也是通过**[头下标：尾下标]**，例如：
list = ['a', '4', '+', '我', ['hello', 3], 'hello', 3.14]
list_2 = [['b', 6], ['c', 9]]
print (list) # 输出完整列表
print (list[4]) # 输出列表的第4个元素
print (list[1:5]) # 输出第2个至第6个元素
print (list[2:]) # 输出从第3个开始至列表末尾的所有元素
print (list_2 * 2) # 输出列表两次
print (list + list_2) # 打印组合的列表
# 结果显示
['a', '4', '+', '我', ['hello', 3], 'hello', 3.14]
['hello', 3]
['4', '+', '我', ['hello', 3]]
['+', '我', ['hello', 3], 'hello', 3.14]
[['b', 6], ['c', 9], ['b', 6], ['c', 9]]
['a', '4', '+', '我', ['hello', 3], 'hello', 3.14, ['b', 6], ['c', 9]]
2.1.4 Tuple
元组数据结构类似于列表，用()表示，内部元素用逗号隔开。元组不能够二次赋值
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
list = ['a', '4', '+', '我', ['hello', 3], 'hello', 3.14]
list[2] = 500 # 列表可以二次赋值
tuple[2] = 'aa' # 元组不能二次赋值
print(list)
print(tuple)
# 结果显示
['a', '4', 500, '我', ['hello', 3], 'hello', 3.14]
TypeError: 'tuple' object does not support item assignment
2.1.5 Dictionary
列表是有序的对象集合，字典是无序的对象集合，用{}表示。字典当中的元素是通过键来存取的，由索引（key）和它对应的值（value）组成。例如：
dict = {
}
dict['one'] = "This is one"
dict[2] = "This is two"
dict_2 = {
'name': 'runoob','code':6734, 'dept': 'sales'}
print(dict)
print(dict['one'], dict[2])
print(dict_2)
print(dict_2.keys())
print(dict_2.values())
# 结果显示
{
'one': 'This is one', 2: 'This is two'}
This is one This is two
{
'name': 'runoob', 'code': 6734, 'dept': 'sales'}
dict_keys(['name', 'code', 'dept'])
dict_values(['runoob', 6734, 'sales'])
3. 运算符
3.1 算术运算符
a = 50, b = 10
| 运算符 | 描述 | 结果 |
|---|---|---|
| + | a + b | 60 |
| - | a - b | 40 |
| * | a * b | 500 |
| / | a / b | 5 |
| % | 取a / b的余数部分 | 0 |
| ** | a ** b(a的b次幂) | 97656250000000000 |
| // | 取a / b的整数部分（向下取整） | 5 |
3.2 比较运算符
a = 50, b = 10
| 运算符 | 描述 | 结果 |
|---|---|---|
| == | a == b | False |
| != | a != b(不等于) | True |
| > | a > b | True |
| < | a < b | False |
| >= | a >= b | True |
| <= | a <= b | False |
3.3 赋值运算符
a = 50, b = 10
| 运算符 | 描述 | 结果 |
|---|---|---|
| = | c = a + b | 60 |
| += | c += a等效于c = c + a | 110 |
| -= | c -= a等效于c = c - a | 10 |
| *= | c *= a等效于c = c * a | 3000 |
| /= | c /= a等效于c = c / a | 1.2 |
| %= | c %= a等效于c = c % a （取余） | 10 |
| **= | c **= a等效于c = c ** a | 略 |
| //= | c //= a 等效于c = c // a（取整） | 1 |
3.4 位运算符
该运算符按二进制位对值进行操作。
a = 50, b = 10 ->a = 0b110010, b = 0b1010
| 运算符 | 描述 | 结果 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值，如果两个相应位都为1，则该位的结果为1，否则为0 | (a & b)结果为2，二进制：0b10 |
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1 | (a | b)结果为58，二进制：0b111010 | |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b)结果为56，二进制：0b111000 |
| ~ | 按位取反运算符：对数据的每个二进制位取反，即把1变为0，把0变为1 | (~ a)结果为-51，二进制：-0b110011 |
| << | 运算数的各二进位全部左移若干位，由<<右边的数字指定了移动的位数，高位丢弃，低位补0 | (a <<2)结果为200，二进制：0b11001000 |
| >> | 把>>左边的运算数的各二进制位全部右移若干位，>>右边的数字指定了移动的位数 | (a >>2)结果为12，二进制：0b1100 |
3.5 逻辑运算符
a = 50, b = 10 ->a = 0b110010, b = 0b1010
| 运算符 | 描述 | 结果 |
|---|---|---|
| and | 布尔"与" .如果 a 和 b 的结果都为True，那么整个结果则为True;如果a 和 b 有任意一个结果是False，那么整个结果则为False | (a and b)返回10 |
| or | 布尔"或" - 如果 a 和 b 只要有一个为True，征提返回True。如果 a 是非 0，它返回 a 的值，否则它返回 b 的计算值。 | (a or b)返回50 |
| not | 布尔"非" - 如果 a 为 True，返回 False 。如果 a 为 False，它返回 True。 | (not b)返回 False |
3.6 成员运算符
| 运算符 | 描述 |
|---|---|
| in | 如果在指定的序列中找到值返回True，否则返回False |
| not in | 如果在指定序列中没有找到值返回True，否则返回False |
3.7 身份运算符
| 运算符 | 描述 | 结果 |
|---|---|---|
| is | 判断两个标识符是否引用自一个对象 | a is b, 类似id(a) == id(b)，若引用的是同一个对象则返回True，否则返回False |
| is not | is not 是判断两个标识符是不是引自不同对象 | a is not b, 类似id(a) != id(b)， 若引用的不是同一个对象则返回True，否则返回False |
a = 10
b = 10
if (id(a) == id(b)):
print('id(a) == id(b)')
else:
print('id(a) != id(b)')
if a is b:
print('id(a) == id(b)')
else:
print('id(a) != id(b)')
# 结果显示
id(a) == id(b)
id(a) == id(b)
3.8 运算符的优先级
| 运算符 | 描述 |
|---|---|
| （） | 小括号 |
| x[i] 或 x[i1:i2] | 索引运算符 |
| ** | 乘方 |
| ~ | 按位取反 |
| +（正）, -（负） | 符号运算 |
| *, /, //, % | 乘除 |
| +，- | 加减 |
| >>, << | 位移 |
| & | 按位与 |
| ^ | 按位异或 |
| | | 按位或 |
| ==、!=、>、>=、<、<= | 比较运算符 |
| is, is not | is 运算符 |
| in, not in | in运算符 |
| not | 逻辑非 |
| and | 逻辑与 |
| or | 逻辑或 |
4. 条件语句
Python语言中指定任何非0和非空值（null）为True，0或者null为False。
基本形式为：
if 判断条件：
执行语句……
else：
执行语句……
当判断条件为多个值时，使用以下形式：
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……
5. 循环语句
5.1 while循环
判断条件可以是任何表达式，任何非零非空的值均为True，当判断条件为False时，循环结束。
while循环基本形式：
while 判断条件(condition)：
执行语句(statements)……
示例：
count = 0
while (count < 5):
print('the count is :', count)
count += 1
print('bye')
结果显示：
the count is : 0
the count is : 1
the count is : 2
the count is : 3
the count is : 4
bye
while循环中可以通过continue来跳过该次循环，break用于退出循环。
while…continue…循环：
i = 0
while i < 8:
i += 1
if i % 2 > 0:
continue
print（i）
# 结果显示
2
4
6
8
while…break…循环：
i = 1
while True:
i += 1
if i > 5:
break
print(i)
# 结果显示
2
3
4
5
while…else…循环（在循环条件为False时执行else语句）：
count = 0
while count < 5:
print(count, ' is less than 5')
count += 2
else:
print(count, 'is more than 5')
# 结果显示
0 is less than 5
2 is less than 5
4 is less than 5
6 is more than 5
5.2 for循环
Python中的for循环可以遍历任何序列的项目，比如列表和字符串。
通过序列索引迭代：
vegetables = [('celery', 1.58), ('brocoli', 1.29), ('lettuce', 2.19)]
dict3 = dict(vegetables)
for index in range(len(vegetables)):
print('当前是：', vegetables[index])
# 结果显示
当前是： ('celery', 1.58)
当前是： ('brocoli', 1.29)
当前是： ('lettuce', 2.19)
for…else…循环，在执行完for中的语句后，执行else中的语句。
for i in range(10,20):
for num in range(2,i):
if i % num == 0:
j = i / num
print('%d等于%d*%d' %(i, num, j))
break
else:
print('%d是一个质数' %(i))
# 结果显示
10等于2*5
11是一个质数
12等于2*6
13是一个质数
14等于2*7
15等于3*5
16等于2*8
17是一个质数
18等于2*9
19是一个质数
5.3 循环嵌套
Python允许在一个循环体里嵌套另一个循环体，比如在while循环中嵌套for循环，在for循环中嵌套while循环等。
使用嵌套循环表示100以内的素数：
i = 2
while i < 100:
j = 2
while j <= (i/j):
if not(i%j):
break
j = j + 1
if j > i/j:
print(i, '是素数')
i =i +1
# 结果显示
2 是素数
3 是素数
5 是素数
7 是素数
11 是素数
13 是素数
17 是素数
19 是素数
23 是素数
29 是素数
31 是素数
37 是素数
41 是素数
43 是素数
47 是素数
53 是素数
59 是素数
61 是素数
67 是素数
71 是素数
73 是素数
79 是素数
83 是素数
89 是素数
97 是素数