Python基础教程-菜鸟教程学习笔记1
文章目录
- Python基础教程-菜鸟教程学习笔记1
- 前言 Python 简介
- 1. 第一个Python程序
- 2. Python 中文编码
- 3. 基本语法
- 1）Python 标识符：
- 2）Python 保留字符
- 3）行和缩进
- 4）一条语句多行显示
- 5）Python引号
- 6）Python注释
- 7）print输出
- 8）多个语句构成代码组
- 9）Python书写基本规范
- 4. Python变量类型
- 1）变量赋值
- 2）多个变量赋值
- 3）标准数据类型
- 4）Python 数字
- 5）Python字符串
- 6）Python列表
- 7）Python元组
- 8）Python字典
- 5. Python运算符
- 1）Python算术运算符
- 2）Python比较运算符
- 3）Python赋值运算符
- 4）Python位运算符
- 5）Python逻辑运算符
- 6）Python成员运算符
- 7）Python身份运算符
- **8）Python运算符优先级**
- 6. Python语句
- **1）条件语句**
- **2）循环语句**
- 3）循环控制语句
- 3）循环控制语句
前言 Python 简介
Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
Python 的设计具有很强的可读性，相比其他语言经常使用英文关键字，其他语言的一些标点符号，它具有比其他语言更有特色语法结构。
- Python 是一种解释型语言： 这意味着开发过程中没有了编译这个环节。类似于PHP和Perl语言。
- Python 是交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
- Python 是面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
- **Python 是初学者的语言：**Python 对初级程序员而言，是一种伟大的语言，它支持广泛的应用程序开发，从简单的文字处理到 WWW 浏览器再到游戏。
1. 第一个Python程序
对于大多数程序语言，第一个入门编程代码便是 “Hello World！”，以下代码为使用 Python 输出 “Hello World！”：
#!/usr/bin/python
print("Hello, World!")
关于脚本第一行的 #!/usr/bin/python 的解释，相信很多不熟悉 Linux 系统的同学需要普及这个知识，脚本语言的第一行，只对 Linux/Unix 用户适用，用来指定本脚本用什么解释器来执行。
有这句的，加上执行权限后，可以直接用 ./ 执行，不然会出错，因为找不到 python 解释器。
#!/usr/bin/python 是告诉操作系统执行这个脚本的时候，调用 /usr/bin 下的 python 解释器。
#!/usr/bin/env python 这种用法是为了防止操作系统用户没有将 python 装在默认的 /usr/bin 路径里。当系统看到这一行的时候，首先会到 env 设置里查找 python 的安装路径，再调用对应路径下的解释器程序完成操作。
#!/usr/bin/python 相当于写死了 python 路径。
#!/usr/bin/env python 会去环境设置寻找 python 目录，可以增强代码的可移植性，推荐这种写法。
分成两种情况：
（1）如果调用 python 脚本时，使用:
python script.py
#!/usr/bin/python 被忽略，等同于注释
（2）如果调用python脚本时，使用:
./script.py
#!/usr/bin/python 指定解释器的路径
PS： shell 脚本中在第一行也有类似的声明。
2. Python 中文编码
Python 文件中如果未指定编码，在执行过程会出现报错：
#!/usr/bin/python
print ("你好，世界")
Python中默认的编码格式是 ASCII 格式，在没修改编码格式时无法正确打印汉字，所以在读取中文时会报错。
解决方法为只要在文件开头加入 # -*- coding: UTF-8 -*- 或者 # coding=utf-8 就行了
注意：****# coding=utf-8 的 = 号两边不要空格。
**注意：**Python3.X 源码文件默认使用utf-8编码，所以可以正常解析中文，无需指定 UTF-8 编码。
**注意：**如果你使用编辑器，同时需要设置 py 文件存储的格式为 UTF-8，否则会出现类似以下错误信息：
SyntaxError: (unicode error) ‘utf-8’ codec can’t decode byte 0xc4 in position 0:
invalid continuation byte
Pycharm 设置步骤：
- 进入 file > Settings，在输入框搜索 encoding。
- 找到 Editor > File encodings，将 IDE Encoding 和 Project Encoding 设置为utf-8。
- 或者pycharm 右下角也可以切换编码。
3. 基本语法
1）Python 标识符：
在 Python 里，标识符由字母、数字、下划线组成。
在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。
Python 中的标识符是区分大小写的。
以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxx import * 而导入。
以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 __foo__代表 Python 里特殊方法专用的标识，如 init() 代表类的构造函数。
Python 可以同一行显示多条语句，方法是用分号 ; 分开，如：
>>> print ('hello');print ('runoob');
hello
runoob
2）Python 保留字符
下面的列表显示了在Python中的保留字。这些保留字不能用作常数或变数，或任何其他标识符名称。
所有 Python 的关键字只包含小写字母。
| and | exec | not |
|---|---|---|
| assert 断言 | finally | or |
| break | for | pass |
| class | from | |
| continue | global | raise |
| def | if | return |
| del | import | try |
| elif | in | while |
| else | is | with |
| except | lambda | yield |
3）行和缩进
python 对格式要求非常严格，学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。
缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。
因此，在 Python 的代码块中必须使用相同数目的行首缩进空格数。
python的基本规范：python要求我们的代码缩进是4个空格或者4的倍数；
**错误提示：**PEP 8: E111 indentation is not a multiple of four
4）一条语句多行显示
Python语句中一般以新行作为语句的结束符。
但是我们可以使用**斜杠（ \）**将一行的语句分为多行显示，如下所示：
total = item_one + \
item_two + \
item_three
语句中包含 [], {} 或 () 括号就不需要使用多行连接符。如下实例：
days = ['Monday', 'Tuesday', 'Wednesday',
'Thursday', 'Friday']
5）Python引号
Python 可以使用引号( ’ )、双引号( " )、三引号( ‘’’ 或 “”" ) 来表示字符串，引号的开始与结束必须是相同类型的。
其中三引号可以由多行组成，编写多行文本的快捷语法，常用于文档字符串，在文件的特定地点，被当做注释。
6）Python注释
python中单行注释采用 # 开头。
python 中多行注释使用三个单引号(’’’)或三个双引号(""")。
7）print输出
print 默认输出换行，python3中，print 是一个函数，可以使用 print(x, end="") ，end="" 可使输出不换行。
# 换行输出
print("hello")
print("world")
print('---------')
# 不换行输出
print("hello", end="")
print("world")
print("hello", end=" ")
print("world")
8）多个语句构成代码组
缩进相同的一组语句构成一个代码块，我们称之代码组。
像if、while、def和class这样的复合语句，首行以关键字开始，以冒号( : )结束，该行之后的一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句(clause)。
9）Python书写基本规范
命名类：
-
Class names should use CamelCase convention，类名称需要使用驼峰命名
当我们定义python类时，应该使用驼峰命名——CamelCase，即单词组合中首字母需要大写。
-
Variable in function should be lowercase，函数中的变量需要使用小写
-
Shadows name ‘use_a’ from outer scope，外部作用域的重复命名
出现这个提示，表示当前代码不同作用域中重复使用了同样的变量名。最常出现的情况就就是方法中的函数变量和__main__下面的变量出现重名。
排版类：
-
PEP 8: W292 no newline at end of file，文件末尾没有新的行：
要求我们在代码的最后在空出一行，一个回车加一行搞定
-
PEP 8: E303 too many blank lines (2)，太多的空行：
-
函数之间，类之间一般要空2行
-
类方法之间一般空1行
-
函数/方法代码内部每行间隔不超过1行
-
-
PEP 8: E501 line too long (166 > 150 characters)，单行代码长度过长，这个长度可以在Pycharm中设置
-
PEP 8: E111 indentation is not a multiple of four，代码缩进不是4的倍数，要求代码缩进是4个空格或者4的倍数
-
PEP 8: E225 missing whitespace around operator，操作符前后未留空白
4. Python变量类型
1）变量赋值
Python 中的变量赋值不需要类型声明，在使用变量前必须要赋值。
每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号 = 用来给变量赋值。
等号 = 运算符左边是一个变量名，等号 = 运算符右边是存储在变量中的值。例如：
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串
print counter
print miles
print name
2）多个变量赋值
Python允许你同时为多个变量赋值。例如：
a = b = c = 1
也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, "john"
3）标准数据类型
Python 定义了一些标准类型，用于存储各种类型的数据。
Python有五个标准的数据类型：
- Numbers（数字）
- String（字符串）
- List（列表）
- Tuple（元组）
- Dictionary（字典）
查看数据类型，python 的所有数据类型都是类,可以通过 type() 查看该变量的数据类型:
n = "runoob"
print(type(n))
# 输出结果
<class 'str'>
4）Python 数字
数字数据类型用于存储数值。
数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值，将重新分配内存空间。
当你指定一个值时，Number 对象就会被创建：
var1 = 1
var2 = 10
您也可以使用del语句删除一些对象的引用。
del语句的语法是：
del var1[,var2[,var3[....,varN]]]
您可以通过使用del语句删除单个或多个对象的引用。例如：
del var
del var_a, var_b
Python支持四种不同的数字类型：
- int（有符号整型）
- long（长整型[也可以代表八进制和十六进制]）
- float（浮点型）
- complex（复数）
实例
一些数值类型的实例：
| int | long | float | complex |
|---|---|---|---|
| 10 | 51924361L | 0.0 | 3.14j |
| 100 | -0x19323L | 15.20 | 45.j |
| -786 | 0122L | -21.9 | 9.322e-36j |
| 080 | 0xDEFABCECBDAECBFBAEl | 32.3e+18 | .876j |
| -0490 | 535633629843L | -90. | -.6545+0J |
| -0x260 | -052318172735L | -32.54e100 | 3e+26J |
| 0x69 | -4721885298529L | 70.2E-12 | 4.53e-7j |
- 长整型也可以使用小写 l，但是还是建议您使用大写 L，避免与数字 1 混淆。Python使用 L 来显示长整型。
- Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b) 表示， 复数的实部 a 和虚部 b 都是浮点型。
**注意：**long 类型只存在于 Python2.X 版本中，在 2.2 以后的版本中，int 类型数据溢出后会自动转为long类型。在 Python3.X 版本中 long 类型被移除，使用 int 替代。
Python数学函数
| 函数 | 返回值 ( 描述 ) |
|---|---|
| abs(x) | 返回数字的绝对值，如abs(-10) 返回 10 |
| ceil(x) | 返回数字的上入整数，如math.ceil(4.1) 返回 5 |
| cmp(x, y) | 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1，在Python3.x中不可用，用其他函数代替 |
| exp(x) | 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045 |
| fabs(x) | 返回数字的绝对值，如math.fabs(-10) 返回10.0 |
| floor(x) | 返回数字的下舍整数，如math.floor(4.9)返回 4 |
| log(x) | 如math.log(math.e)返回1.0,math.log(100,10)返回2.0 |
| log10(x) | 返回以10为基数的x的对数，如math.log10(100)返回 2.0 |
| max(x1, x2,…) | 返回给定参数的最大值，参数可以为序列。 |
| min(x1, x2,…) | 返回给定参数的最小值，参数可以为序列。 |
| modf(x) | 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。 |
| pow(x, y) | x**y 运算后的值。 |
| round(x [,n]) | 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。 |
| sqrt(x) | 返回数字x的平方根 |
range()函数
>>> range(1,5) # 代表从1到5(不包含5)
[1, 2, 3, 4]
>>> range(1,5,2) # 代表从1到5，间隔2(不包含5)
[1, 3]
>>> range(5) # 代表从0到5(不包含5)
[0, 1, 2, 3, 4]
注意：默认情况下，range() 的起始值是 0。
数字转化为 对应ASCII：
ord('b') # convert char to int
98
chr(100) # convert int to char
'd'
abs() 和 fabs() 区别
- 1、abs()是一个内置函数，而fabs()在math模块中定义的。
- 2、fabs()函数只适用于float和integer类型，而 abs() 也适用于复数。
abs(-10)
10
import math
math.fabs(-10)
10.0
5）Python字符串
字符串或串(String)是由数字、字母、下划线组成的一串字符。
python的字串列表有2种取值顺序:
- 从左到右索引默认0开始的，最大范围是字符串长度少1
- 从右到左索引默认-1开始的，最大范围是字符串开头
如果你要实现从字符串中获取一段子字符串的话，可以使用 [头下标:尾下标] 来截取相应的字符串，其中下标是从 0 开始算起，可以是正数或负数，下标可以为空表示取到头或尾。
[头下标:尾下标] 获取的子字符串包含头下标的字符，但不包含尾下标的字符。
s = 'abcdef'
print(s[1:5])
# 输出结果
'bcde'
加号（+）是字符串连接运算符，星号（*）是重复操作。如下实例：
str = 'Hello World!'
print(str) # 输出完整字符串
print(str[0]) # 输出字符串中的第一个字符
print(str[2:5]) # 输出字符串中第三个至第六个之间的字符串
print(str[2:]) # 输出从第三个字符开始的字符串
print(str * 2) # 输出字符串两次
print(str + "TEST") # 输出连接的字符串
# 实际输出结果
Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST
Python 列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
Python字符串运算符
下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：
| 操作符 | 描述 | 实例 |
|---|---|---|
| + | 字符串连接 | >>>a + b ‘HelloPython’ |
| * | 重复输出字符串 | >>>a * 2 ‘HelloHello’ |
| [] | 通过索引获取字符串中字符 | >>>a[1] ‘e’ |
| [ : ] | 截取字符串中的一部分 | >>>a[1:4] ‘ell’ |
| in | 成员运算符 - 如果字符串中包含给定的字符返回 True | >>>“H” in a True |
| not in | 成员运算符 - 如果字符串中不包含给定的字符返回 True | >“M” not in a True |
| r/R | 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用， 没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前 加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。 | >>>print r’\n’ \n >>> printR’\n’ \n |
| % | 格式字符串 | 请看下一章节 |
Python 支持格式化字符串的输出
print("My name is %s and weight is %d kg!" % ('Zara', 21))
转义字符 \
print('Let\'s go!')
6）Python列表
列表的数据项不需要具有相同的类型，创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。
访问列表中的值使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
# 输出结果：
list1[0]: physics
list2[1:5]: [2, 3, 4, 5]
更新列表对列表的数据项进行修改或更新，可以使用append()方法在列表尾部添加列表项，如下所示：
| 更新列表 | 含义 | 用法 |
|---|---|---|
| append() | 在列表尾部添加单个列表项 | list.append(‘Google’) |
| extend() | 在列表尾部添加多个列表项 | list.extend([‘Google’, ‘Runoob’]) |
| insert() | 在某个位置添加列表项 | list.insert(1, ‘Runoob’) |
list = [] # 空列表
list.append('Google') # 使用 append() 添加元素
list.extend(['Rab', 'hat'])
list.insert(1, 'tube')
print(list)
# 输出结果：
['Google', 'tube', 'Rab', 'hat']
**删除列表元素：**可以使用 del 语句来删除列表的元素，如下实例：
list1 = ['physics', 'chemistry', 1997, 2000]
print(list1)
del list1[2]
print "After deleting value at index 2 : "
print(list1)
# 输出结果：
['physics', 'chemistry', 1997, 2000]
After deleting value at index 2 :
['physics', 'chemistry', 2000]
remove 和 del 之间的区别：
remove不是一个函数，remove()方法删除列表中值为 x 的第一个元素。如果没有这样的元素，会返回一个错误；
del语句按照索引位置删除元素
pop()方法接受的是元素的下标，在原列表中弹出这个元素，并返回，当（）内无索引数时默认弹出最后一个元素。
a = [1, 2, 3, 5, 4, 2, 6]
a.remove(3) # 直接删掉某个元素，
del(a[3]) # del是一个函数，删除带下表的元素
number.pop() # 无索引弹出最后一个元素
number.pop(1) # 弹出索引为1的元素
Python列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。
如下所示：
| Python 表达式 | 结果 | 描述 |
|---|---|---|
| len([1, 2, 3]) | 3 | 长度 |
| [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
| [‘Hi!’] * 4 | [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] | 重复 |
| 3 in [1, 2, 3] | True | 元素是否存在于列表中 |
| for x in [1, 2, 3]: print x, | 1 2 3 | 迭代 |
Python列表截取
Python 的列表截取实例如下：
L = ['Google', 'Runoob', 'Taobao']
L[2] # 读取列表中第三个元素
'Taobao'
L[-2] # 读取列表中倒数第二个元素
'Runoob'
L[1:] # 从第二个元素开始截取列表
['Runoob', 'Taobao']
7）Python元组
元组是另一个数据类型，类似于 List（列表）。
元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。
以下是元组无效的，因为元组是不允许更新的。而列表是允许更新的：
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 ) # 元组
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ] # 列表
tuple[2] = 1000 # 元组中是非法应用
list[2] = 1000 # 列表中是合法应用
元组的一级元素不可被修改增加删除但可以修改二级后的。如修改元祖中列表，字典等内容:
tu = ("alex", [11, 22, {"k1": 'v1', "k2": ["age", "name"], "k3": (11,22,33)}, 44])
tu[1][2]["k2"].append("seven")
print(tu[1][2]["k2"])
# 输出结果
['age', 'name', 'seven']
元组中只包含一个元素时，需要在元素后面添加逗号，否则被当做括号运算
tup1 = (50,)
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print tup3
# 输出结果
(12, 34.56, 'abc', 'xyz')
==注意：==切片虽然可以重新组成新的元组，但是要注意截取一个元素时候不能和新的元组相 ＋：
a=(1,2,3,4,5,6)
c=a[1:4]+a[5] # 报错, a[5] 被当成了整型
c=a[1:4]+a[2:4] # 这样可以
c
(2, 3, 4, 3, 4)
# 如果截取的是一个元素，则可以写成：
c=a[1:4]+a[5:]
# a[5] 得到的是整型量 6, 而 a[5:] 得到的是新元组 (6,)，所以元组拼接时用 a[5] 会报错
任意无符号的对象，以逗号隔开，默认为元组。
Python元组包含内置函数：
| 序号 | 方法及描述 |
|---|---|
| 1 | cmp(tuple1, tuple2) 比较两个元组元素。 |
| 2 | len(tuple) 计算元组元素个数。 |
| 3 | max(tuple) 返回元组中元素最大值。 |
| 4 | min(tuple) 返回元组中元素最小值。 |
| 5 | tuple(seq) 将列表转换为元组。 |
8）Python字典
字典(dictionary)是除列表以外最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
-
字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号分割，整个字典包括在花括号 {} 中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
-
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。
-
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组，可以混用，不能用列表[]表示。
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
print(dict['one'] ) # 输出键为'one' 的值
print(dict[2]) # 输出键为 2 的值
print(tinydict) # 输出完整的字典
print(tinydict.keys()) # 输出所有键
print(tinydict.values()) # 输出所有值
# 输出结果为：
This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'runoob'}
dict_keys(['name', 'code', 'dept'])
dict_values(['runoob', 6734, 'sales'])
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8 # 更新
dict['School'] = "RUNOOB" # 添加
print "dict['Age']: ", dict['Age']
print "dict['School']: ", dict['School']
dict.clear() # 删除字典内所有元素
字典的键可以使用布尔类型的，True 默认代表 1，False 默认代表 0，如果包含 0 或 1 就无法使用布尔类型：
# 包含 0 或 1 的情况下：
test = {0:"1", 1:"2", True:"3", False:"4"}
print(test)
{0: '4', 1: '3'}
# 没有 0 或 1 的情况下：
test = {"a":"1", "b" :"2", True:"3", False:"4"}
print(test)
{'a': '1', True: '3', 'b': '2', False: '4'}
访问字典里的值的时候，如果直接用 [] 访问，在没有找到对应键的情况下会报错，一个更好的替代方案是用内置的 get 方法来取键值，这时候如果不存在也不会报错。
test = {'key1':'value1','key2':'value2'}
test['key3'] 报错：KeyError:'key3'
test.get('key3') 无输出
test.get('key3','default') 输出'default'
5. Python运算符
1）Python算术运算符
以下假设变量： a=10，b=20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 30 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
| / | 除 - x除以y | b / a 输出结果 2，取整数 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 0 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的20次方， 输出结果 100000000000000000000 |
| // | 取整除 - 返回商的整数部分（向下取整） | >>> 9//2=4 >>> -9//2=-5 |
2）Python比较运算符
以下假设变量a=10，变量b=20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。 | (a < b) 返回 true。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 true。 |
3）Python赋值运算符
以下假设变量a为10，变量b为20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c **= a 等效于 c = c ** a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
4）Python位运算符
按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
程序示例
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b # 12 = 0000 1100
print("1 - c 的值为：", c)
c = a | b # 61 = 0011 1101
print("2 - c 的值为：", c)
c = a ^ b # 49 = 0011 0001
print("3 - c 的值为：", c)
c = ~a # -61 = 1100 0011
print("4 - c 的值为：", c)
c = a << 2 # 240 = 1111 0000
print("5 - c 的值为：", c)
c = a >> 2 # 15 = 0000 1111
print("6 - c 的值为：", c)
5）Python逻辑运算符
Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:
| 运算符 | 逻辑表达式 | 描述 | 实例 |
|---|---|---|---|
| and | x and y | 布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 | (a and b) 返回 20。 |
| or | x or y | 布尔"或" - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。 | (a or b) 返回 10。 |
| not | not x | 布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not(a and b) 返回 False |
6）Python成员运算符
除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
以下实例演示了Python所有成员运算符的操作：
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
if a in list:
print("1 - 变量 a 在给定的列表中 list 中")
else:
print("1 - 变量 a 不在给定的列表中 list 中")
if b not in list:
print("2 - 变量 b 不在给定的列表中 list 中")
else:
print("2 - 变量 b 在给定的列表中 list 中")
7）Python身份运算符
身份运算符用于比较两个对象的存储单元
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
8）Python运算符优先级
以下表格列出了从最高到最低优先级的所有运算符：
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 ‘AND’ |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is， is not | 身份运算符 |
| in， not in | 成员运算符 |
| not， and， or | 逻辑运算符 |
is 与 == 区别 ：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
a is b 相当于 id(a)==id(b)，id() 能够获取对象的内存地址。
如果 a=10;b=a; 则此时 a 和 b 的内存地址一样的;
但当 a=[1,2,3]; 另 b=a[:] 时，虽然 a 和 b 的值一样，但内存地址不一样。
6. Python语句
1）条件语句
Python 编程中 if 语句用于控制程序的执行，基本形式为：
if 判断条件：
执行语句……
else：
执行语句……
if 语句的判断条件可以用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。
当判断条件为多个值时，可以使用以下形式：
if 判断条件1:
执行语句1……
elif 判断条件2:
执行语句2……
elif 判断条件3:
执行语句3……
else:
执行语句4……
由于 python 并不支持 switch 语句，所以多个条件判断，只能用 elif 来实现，如果判断需要多个条件需同时判断时，可以使用 or （或），表示两个条件有一个成立时判断条件成功；使用 and （与）时，表示只有两个条件同时成立的情况下，判断条件才成功。
当if有多个条件时可使用括号来区分判断的先后顺序，括号中的判断优先执行，此外 and 和 or 的优先级低于>（大于）、<（小于）等判断符号，即大于和小于在没有括号的情况下会比与或要优先判断。
**python 复合布尔表达式计算采用短路规则，即如果通过前面的部分已经计算出整个表达式的值，则后面的部分不再计算。**如下面的代码将正常执行不会报除零错误：
a = 0
b = 1
if ( a > 0 ) and ( b / a > 2 ): # a>0条件已经不满足，不用再执行b/a>2，所以不会报错
print("yes")
else:
print("no")
而下面的代码就会报错：
a = 0
b = 1
if ( a > 0 ) or ( b / a > 2 ):
print("yes")
else:
print("no")
三元操作符：
small = x if x < y else y
2）循环语句
Python 提供了 for 循环和 while 循环（在 Python 中没有 do…while 循环）:
| 循环类型 | 描述 |
|---|---|
| while 循环 | 在给定的判断条件为 true 时执行循环体，否则退出循环体。 |
| for 循环 | 重复执行语句 |
| 嵌套循环 | 你可以在while循环体中嵌套for循环 |
- while 循环语句
基本形式为：
while 判断条件(condition)：
执行语句(statements)……
循环体
Gif 演示 Python while 语句执行过程：
复杂一点：
在 python 中，while … else 在循环条件为 false 时执行 else 语句块：
count = 0
while count < 5:
print(count, " is less than 5")
count = count + 1
else:
print(count, " is not less than 5")
如果 while 循环体中只有一条语句，你可以将该语句与while写在同一行中.
- for 循环语句
Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串。
for循环的语法格式如下：
for iterating_var in sequence:
statements(s)
for 目标 in 表达式：
循环体
流程图：
for letter in 'Python':
print('当前字母：', letter)
# 输出结果
当前字母： P
当前字母： y
当前字母： t
当前字母： h
当前字母： o
当前字母： n
通过序列索引迭代：
fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print('当前水果:', fruits[index])
内置函数 len() 和 range()，函数 len() 返回列表的长度，即元素的个数。
range返回一个序列的数，即(0,3)，不包括3。
for num in range(10, 20):
for i in range(2, num):
if num % i == 0:
j = num / i
print('%d 等于 %d * %d' % (num, i, j))
break
else:
print(num, '是一个质数')
range()用法：不包括下标
range(4) # 打印0,1,2,3 （下标）
range(1:5) # 打印1,2,3,4 （上标：下标）
range(2:10:3) # 打印2,5,8 (上标：下标：步长)
-
循环嵌套
Python 语言允许在一个循环体里面嵌入另一个循环。
Python for 循环嵌套语法：
for iterating_var in sequence: for iterating_var in sequence: statements(s) statements(s)
Python while 循环嵌套语法：
while expression: while expression: statement(s) statement(s)
你可以在循环体内嵌入其他的循环体，如在while循环中可以嵌入for循环， 反之，你可以在for循环中嵌入while循环。
实例：
以下实例使用了嵌套循环输出2~100之间的素数：素数：（质数prime number）定义为在大于1的自然数中，除了1和它本身以外不再有其他因数。
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 print("Good bye!")# 冒泡排序，从最后一个数跟倒数第二个数比较大小，再重新排，最后输出新的列表 array = [9, 2, 7, 4, 5, 6, 3, 8, 1, 10] L = len(array) for i in range(L): for j in range(L-i): if array[L-j-1] < array[L-j-2]: array[L-j-1], array[L-j-2] = array[L-j-2], array[L-j-1] for i in range(L): print(array[i])
3）循环控制语句
循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：
| 控制语句 | 描述 |
|---|---|
| break 语句 | 在语句块执行过程中终止循环，并且跳出整个循环。 |
| continue 语句 | 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。 |
| pass 语句 | pass是空语句，是为了保持程序结构的完整性。 |
f j > i / j:
print(i, “是素数”)
i = i + 1
print(“Good bye!”)
```python
# 冒泡排序，从最后一个数跟倒数第二个数比较大小，再重新排，最后输出新的列表
array = [9, 2, 7, 4, 5, 6, 3, 8, 1, 10]
L = len(array)
for i in range(L):
for j in range(L-i):
if array[L-j-1] < array[L-j-2]:
array[L-j-1], array[L-j-2] = array[L-j-2], array[L-j-1]
for i in range(L):
print(array[i])
3）循环控制语句
循环控制语句可以更改语句执行的顺序。Python支持以下循环控制语句：
| 控制语句 | 描述 |
|---|---|
| break 语句 | 在语句块执行过程中终止循环，并且跳出整个循环。 |
| continue 语句 | 在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环。 |
| pass 语句 | pass是空语句，是为了保持程序结构的完整性。 |
更多推荐
Python基础教程-菜鸟教程学习笔记1
发布评论