Python基础

Python基础

---

---

一、python简介

1. 机器、汇编、高级语言

1.1 机器语言

​ 机器语言直接采用二进制编程，直接操作硬件，属于低级语言（低级语言：底层、贴近计算机硬件）。

机器语言优缺点：

优点：

1. 编写的程序可以被计算机无障碍理解、直接运行，执行效率高

缺点：

1. 复杂、开发效率低
2. 贴近\依赖具体的硬件，跨平台性差

1.2 汇编语言

​ 汇编语言采用英文标签代替二进制指令，比起机器语言是一种进步，本质仍然是直接操作硬件，还是属于低级语言（底层\贴近计算机硬件）。

汇编语言优缺点：

优点：

1. 相对于机器语言，使用英文标签编写程序相对简单，执行效率稍低，开发效率稍高

缺点：

1. 直接操作硬件，比起机器语言，复杂度稍低，但依旧居高不下，所以开发效率依旧较低
2. 依赖具体的硬件、跨平台性差

1.3 高级语言

​ 高级语言操控操作系统，高级指高层、开发者无需考虑硬件细节，开发效率极大提升，但执行效率低于低级语言。高级语言分为两种：编译型和解释型。

1.3.1 编译型（如C语言）

​ 编译型：类似于谷歌翻译，把程序所有代码编译成计算机能识别的二级制指令，之后操作系统拿着编译好的二级制指令操作硬件。

编译型语言优缺点：

优点

1. 编译一次后，可以拿结果重复使用，无需再次翻译，执行效率高于解释型

缺点

1. 编译型代码针对某一个平台翻译，当前平台翻译结果无法拿到另外一个平台使用，即无法跨平台

1.3.2 解释型（如Python）

​ 解释型：类型于同声翻译，需要一个解释器，解释器读取程序代码，一边翻译一边执行。

解释型语言优缺点：

优点

1. 代码运行依赖解释器，不同平台有相对应的解释器，所以代码可以跨平台运行

缺点

1. 每次执行都需要翻译，执行效率低于编译型

1.4 总结

1. 执行效率：机器语言>汇编语言>高级语言（编译型>解释型）
2. 开发效率：机器语言<汇编语言<高级语言（编译型<解释型）
3. 跨平台性：解释型语言具有极强的平台型

2.Python介绍

​ Python 是一种解释型、面向对象的高级程序设计语言，其创始人为荷兰吉多·范罗苏姆（Guido van Rossum）。Python 自20世纪90年代初诞生至今，在多个领域有着广泛用途：1.Web 和 Internet 开发；2.科学计算与统计；3.人工智能；4.教育；5.软件开发；6.后端开发；7.网络爬虫；8.机器学习…………

2.1 Python的种类

2.1.1 CPython

​ Python的官方版本，使用C语言实现，使用最为广泛，CPython实现会将源文件（py文件）转换为字节码（pcy文件），然后运行在Python虚拟机上。

2.1.2JPython

​ JPython解释器是用JAVA编写的python解释器，可以直接把Python代码编译成Java字节码并执行，它不但使基于java的项目之上嵌入python脚本成为可能，同时也可以将java程序引入到python程序之中。

2.1.3 IPython

​ IPython是基于CPython之上的一个交互式解释器，也就是说，IPython只是在交互方式上有所增强，但是执行Python代码的功能和CPython是完全一样的。这就好比很多国产浏览器虽然外观不同，但内核其实都是调用了IE。CPython用>>>作为提示符，而IPython用In [序号]:作为提示符。

2.1.4 PyPy

​ PyPy是Python开发者为了更好地Hack Python而用Python语言实现的Python解释器。PyPy提供了JIT编译器和沙盒功能，对Python代码进行动态编译（注意不是解释），因此运行速度比CPython还要快。

2.1.5 IronPython

​ IronPython和Jython类似，只不过IronPython是运行在微软.Net平台上的Python解释器，可以直接把Python代码编译成.Net的字节码。

2.2 安装Python解释器

2.2.1 下载Python解释器

Python官网：Python

根据具体平台下载相对应的版本

2.2.2 安装Python解释器

2.2.3 测试是否安装成功

​ windows–>运行–>输入cmd–>，回车，弹出cmd程序，输入python，如果进入交互环境，代表安装成功。

---

---

二、字节与编码

2.1 位与字节

2.1.1 位（bit）

​ 1位表示1个二进制数，如：1010就代表有4位

2.1.2 字节（Byte）

​ 1个字节有8位，两者换算关系为：1Byte=8bit

2.2 编码

2.2.1 ASCII编码

	ASCII编码是最初美国的语言编码，采用8个二进制来表示1个符号或字母，共有2^8^=256种变化

2.2.2 unicode编码

​ unicode 编码是全世界通用编码，适合各个国家编码使用。

2.2.3 utf-8编码

​ utf-8编码采用3字节表示，包含世界所有国家需要的字符。

2.2.4 GBK编码

​ GBK编码中国汉字编码，采用2字节表示。

​ unicode与GBK、utf-8都可以相互转换，但GBK与utf-8不能相互转换

---

---

三、输入、输出

1. 输出print函数

print('你好！')
# => 你好！
print(4)
# => 4

2.输入input函数

message = input('请输入信息：') # 直到输入信息，才会执行下一步
print(message)
# =>请输入信息：你是谁
# =>你是谁

3.注释

​ 注释就是对代码进行解释说明，注释的内容不会被当作代码运行，可以增强代码的可读性。

3.1 单行注释（#）

# 单行注释“#”井号
print('hello world')  # 打印“hello world”

3.2 多行注释（’’’）

'''多行注释
三引号'''

---

---

四、变量

1.Hello World

1.1 打印“Hello World”

​ Python运行程序的文件格式为 .py 文件，输出 “Hello World”.

print('Hello World!')
# =>Hello World!

2.变量

变量的命名规则

• 变量命名必须为数字、字母和下划线，不能含有空格。变量名不能以数字开头。如：message_1、_message

• 变量名不能包含空格，但可使用下划线来分割其中的单词。如：message_one

• 变量名不能使用Python的关键字。如：and/as/assert/break/class/continue/def/del/elif/else/except/exec/finally/for/from/

global/if/import/in/is/lambda/not/or/pass/print/raise/return/try/while/with/yield

• 变量名尽量不要与Python内置东西重复

• 变量名应既简短有具有描述性

message = 'Hello World!'
print(message)
# => Hello World!

---

---

五、判断与循环

1.判断语句

1.1 if……语句

1.1.1 格式规范

if ××××:
    #条件 #英文冒号 #自动缩进4个空格
    print(××××)

# 命令逻辑：如果……就……
# 命令格式：if条件后跟英文冒号，回车后自动缩进

1.1.2 举例

#判断输入数字是否大于10，大于10输出“你真棒！”,小于10不输出结果
num = int(input('请输入数字：'))
if num >= 10:
    print("你真棒！")

1.2 if……else……语句

1.2.1 格式规范

if  ××××:
    #条件
    print(××××)
else:    #与if语句同一级别
    #当if条件不满足时
    print(××××)

# 命令逻辑：如果……不满足……就……
# 命令格式：if 与 else属于同一级别，if不满足才会执行else,两者执行其中之一

1.2.2 举例

1 # #判断输入数字是否大于10，大于10输出“你真大！”,小于10输出“你真小！”
2 num = int(input('请输入数字：'))
3 if num >= 10:
4     print("你真大！")
5 else:
6     print("你真小！")

1.3 if……elif……else……语句

1.3.1 格式规范

if ××××:
    #条件1
    print(××××)
elif ××××:
    #条件2
    print(××××)
elif ××××:
    #条件3
    print(××××)
else:    #与if、else语句都同一级别
    #当if和elif条件都不满足时
    print(××××)

# 命令逻辑：如果……不满足……就下一个……再下一个……
# 命令格式：if、elif、else都属于同一级别且条件都是互斥的

1.3.2 举例

# 判断输入的数字是否在10~20之间，0~10输出“有点小！”，10~20输出“范围正好”，大于30输出“有点大！”
num = int(input('请输入数字：'))
if 0 < num < 10:
    print("有点小！")
elif 10 <= num <= 20:
    print("范围正好！")
else:
    print("有点大！")

1.4 if……else……嵌套语句

1.4.1 格式规范

if ××××: #条件套条件，就是在基础条件上再附加一个额外条件
    print(××××)
    if ××××: #额外条件需要缩进
        print(××××)
    else:
        print(××××)
else:   #根据缩进判断层级，根据层级按行执行
    print(××××)
    if ××××:
        print(××××)
    else:
        print(××××)

1.4.2 举例

# 判断学生成绩所属范围
# 1.学生成绩大于等于60分，及格：
#   1）成绩大于等于80分，优秀：
#   2）否则，一般；
# 2.学生成绩小于60分，不及格：
#   1）成绩小于30，学渣
#   2）成绩大于等于30，抓紧抢救！
num = int(input('输入学生成绩：'))
if num >= 60:
    print('及格')
    if num >= 80:
        print('优秀')
    else:
        print('一般')
else:
    print('不及格')
    if num < 30:
        print('学渣')
    else:
        print('抓紧抢救！')
print('程序结束')

2.循环语句

2.1 while循环

2.1.1 正常循环（活循环）

# 循环
num = 0  # 定义变量
while num < 5:  # 设定条件
    num += 1  # 变量变化，不变换会变成死循环
    print(num)

2.1.2 死循环（条件变量需要变化）

# 死循环
num = 0  # 定义变量
while num < 5:  # 设定条件
    print(num)  

2.1.3 while循环练习

1. 求 1~100 内的所有数的和

sum = 0
n = 1
while n < 100:
    sum += n
    n += 1
print(sum)

2. 求1-2+3-4+5 … 99的所有数的和

sum = 0
n = 1
while n < 100:
    temp = n % 2
    if temp == 1:
        sum = sum + n
    else:
        sum = sum - n
    n += 1
print(sum)

2.2 for循环

2.2.1 for……in……循环，遍历列表

1. 格式规范

# for……in……循环，遍历列表
for i in [1,2,3,4,5]:   # 遍历列表，英文冒号
    print(i*5)          # 缩进，重复执行

2. 举例

# 打印列表里所有元素2 list = ['一','二','三','四','五']
for Love in list:
    print(Love)

2.2.2 for……in……循环，遍历字典

1. 格式规范

# for……in……循环，遍历字典
2 for i in {'中国':'北京','日本':'东京','法国':'巴黎'}:   # 遍历字典，英文冒号
    print(i)  

2. 举例

# 打印字典里的键和值
dict={'小明':'买醋','小红':'买油','小白':'买盐','小张':'买米'}
for i in dict:
    print(i+dict[i])
# =>小明买醋
# =>小红买油
# =>小白买盐
# =>小张买米

2.2.3 for……in……循环，遍历元组

1. 规格规范

# for……in……循环,遍历元组
for i in (1,2,3,4,5):   # 遍历元组，英文冒号
    print(i)          # 缩进，重复执行

2. 举例

# 将元组中的各个元素进行输出
tuple = ('我','爱','你','中','国')
for i in tuple:
    print(i)

2.2.4 for……in……循环，遍历字符串

1. 格式规范

# for……in……循环,遍历字符串
for i in '我爱你':   # 列表字符串，英文冒号
    print(i)          # 缩进，重复执行

2. 举例

# 将字符串中的各个字符进行输出
str = '床前明月光，疑是地上霜！'
for i in str:
    print(i)

2.2.5 for……in……循环,range()函数

1. range(x)

for i in range(3): #使用range(x)函数，生成一个 0 到 x-1 的整数序列
    print(i)
# =>0
# =>1
# =>2

2. range(a,b)

for i in range(1,5): #使用range(a,b)函数，生成一个 连续取a不取b的整数序列（取头不取尾）
    print(i)
# =>1
# =>2
# =>3
# =>4

3. range(a,b,c)

for i in range(1,10,2): #使用range(a,b,c)函数，生成一个连续间隔为c的取a不取b的整数序列（取头不取尾）
    print(i)
# =>1
# =>3
# =>5
# =>7
# =>9

4. 举例

# 采用for循环完成1到100内所有整数分别乘以5的计算
for i in range(1,101):
    print(i*5) 

---

---

六、break、continue、pass和else特殊语句

1.break语句

​ break语句是“打破”的意思，用来结束所有循环，跳出循环，一般写作 if…break。

# break语句在for循环中的应用
for i in range(5,10):
    print (i)
    if i>7:
        break

# break语句在while循环中的应用
a=1
while a:
    print (a)
    a=a+1
    if a==10:
        break

# break语句在双层循环中
a=10
while a<=12:
    a=a+1
    for i in range(1,7):
        print (i)
        if i==5:
            break

2.continue 语句

​ 终止当前循环，开始下一次循环，while循环体内continue后语句不在执行。

# continue 语句应用于while循环中
n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0:      # 如果n是偶数，执行continue语句
        continue        # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)

3.pass 语句

​ pass 代指空代码，无意义，仅仅用于代码块

for i in range(5) :
    if i < 3:
        print(i)
    else :
        pass  # 不做任何事情，就是用作占位符

4.else 语句

count=0
while count<10:
    print(count)
    count=count+1
else:
    print('else')
print('......')

七、布尔值与布尔运算

1. 布尔值与布尔运算

布尔值分为真（True）和假（False）==两种，计算真假的过程叫做 “布尔运算” 。

1.1 举例

print(3<5)              # True
print(3>5)              # False
print('长安'=='长安')    # True
print('长安'!='金陵')    # True

1.2 while、if与布尔值

1.2.1 while与布尔值

while True:
    print('hello world!')  # 条件为真，print语句一直执行

while False:
    print('hello world!')  # 条件为假，不执行下面语句

1.2.2 if与布尔值

if True:
    print('正确')
# =>正确
if False:
    print('错误')  #不执行

1.3 布尔值真假判断

假的	真的
False	True
0	3(任意数字)，8.6（任意浮点数）
‘’ (空字符串)	‘我爱你’（任意非空字符串）
[] (空列表)	[1,2,3]
{} （空字典）	{‘1’:‘one’,‘2’:‘two’,‘3’:‘three’}
None

1.4 布尔值之间的运算

1.4.1 and 运算

True and True	真
True and False	假
False and True	假
False and False	假

1.4.2 or 运算

True and True	真
True and False	真
False and True	真
False and False	假

# and 和 or 运算
a = 1
b = -1
print('and 运算')
if a == 1 and b == 1:  #【a=1并且b=1】，两个条件都满足，才为True
    print(True)
else:
    print(False)

print('or 运算')       #【a=1或者b=1】，只要两个条件满足其中之一，就为True
if a == 1 or b == 1:
    print(True)
else:
    print(False)

# and 运算
# False
# or 运算
# True

1.4.3 and和or混合运算

# and 和 or 运算
a = '我'
b = '是'
c = '英'
d = '雄'
if a == '我' or (b == '你' and c == '英' )or d == '雄':
    print(True)
else:
    print(False)
# =>True
if a == '我' or b == '你' and c == '是' and d == '雄':
    print(True)
else:
    print(False)
# =>True
if a == '我' and b == '你' and c == '英' or d == '雄':
    print(True)
else:
    print(False)
# =>True
if a == '你' or b == '我' and c =='英' or d == '雄':
    print(True)
else:
    print(False)
# =>True
if a == '你' and b == '我' or c == '英' or d == '雄':
    print(True)
else:
    print(False)
# =>True

and 和 or 知识点总结：

1. 在判断真假时，有括号先进行括号内的判断；
2. 当有多个and 和 or 连接时，遵守从前到后的顺序进行；
3. 判断结果：

• True or ==> True (当第一个判断结果为True时，后面接or，则整个判断语句为True)
• True and ==> 继续往下判断（当第一个判断结果为True时，后面接and，则继续向下执行，直到整个判断语句结束）
• False or ==> 继续往下判断（当第一个判断结果为False时，后面接or，则继续向下执行，直到整个判断语句结束）
• False and ==> False (当第一个判断结果为False时，后面接and，则整个判断语句为False)

1.4.4 not 运算

not True	假
not False	真

a = True
b = False
print(not a)
print(not b)

1.4.5 in 和 not in 运算

# 判断输入的数字是否在指定列表中,若在输出‘True’,不在输出‘False’
list = [1,2,3,4,5,6,7,8,9,10]
a = input('请输入数字：')
if a in list:
    print(True)
else:
    print(False)

---

---

八、运算符

1. 算术运算符

算术运算符：+、-、*、/、**、//、%，与数学运算一致

# 算术运算符
a = 15
b = 4
print(a+b) # 加
# =>19
print(a-b) # 减
# =>11
print(a*b) # 乘
# =>60
print(a/b) # 除
# =>3.75
print(a**b) # 幂
# =>50625
print(a//b) # 取商
# =>3
print(a%b)  # 取余
# =>3

2. 比较运算符

比较运算符： ==、!=、>、>=、<、<=，比较两个数值大小

a = 9
b = 5
print(a==b)  # 等于
# =>False
print(a!=b)   # 不等于
# =>True
print(a>b)   # 大于
# =>True
print(a>=b)   # 大于等于
# =>True
print(a<b)   # 小于
# =>False
print(a<=b)   # 不等于
# =>False

3.逻辑运算符

逻辑运算符：and、or、not.运算，见上述布尔运算。

4.身份运算符

is : 比较id内存地址，两个对象id相同则返回True

is not : 两个对象id不同时则返回False

(注意：== 双等号比较的是value是否相等，而is比较的是id是否相等)

a = 'love'
b = 'you'
c = 'love'
print(id(a))  # a的内存地址
# =>3222694780272
print(id(b))  # b的内存地址
# =>3222694780720
print(id(c))  # c的内存地址
# =>3222694780272
print(a is b)
# =>False
print(a is c)
# =>True
print(a is not b)
# =>True
print(a is not c)
# =>False

5.赋值运算符

5.1 增量赋值

赋值运算符	描述	案例
=	简单赋值	x = 10
+=	加法赋值	x += 1 #等同于x = x+1
-=	减法赋值	x -= 1 #等同于x = x-1
*=	乘法赋值	同上
/=	除法赋值	同上
//=	取整除赋值	同上
%=	取余赋值	同上
**=	幂赋值	同上

5.2 链式赋值

把同一个值赋值给多个变量

x = y = z = 10
print(x,y,z)
# =>10 10 10

5.3 交叉赋值

交换两个变量

x = 10
y = 5
x,y = y,x   # 交换两个变量的值
print(x,y)
# =>5 10

5.4 解压赋值

将列表中多个值依次赋值给多个变量名

# 全部匹配
lis = [1,2,3,4,5]
a,b,c,d,e = lis   # 左边变量名必须与右面列表所含个数相同，否则报错
print(a,b,c,d,e)
# =>1 2 3 4 5
# 只匹配开头几个值
a,b,*_ = lis
print(a,b)
# =>1 2
# 只匹配结尾几个值
*_,a,b = lis
print(a,b)
# =>4 5

字符串、字典、元组、集合类型都可支持解压赋值

st = 'love'
dic = {1:'one',2:'two',3:'three',4:'four'}
tu = (1,2,3,4)
se = {1,2,3,4}
a,b,c,d = st  # 解压字符串
print(a,b,c,d)
# =>l o v e
a,b,c,d = dic  # 解压字典（只取字典的键）
print(a,b,c,d)
# =>1 2 3 4
a,b,c,d = dic.values()   # 解压字典（只取字典的值）
print(a,b,c,d)
# =>one two three four
a,b,c,d = dic.items()   # 解压字典（取字典的键和值，组成单个元组）
print(a,b,c,d)
# =>(1, 'one') (2, 'two') (3, 'three') (4, 'four')
a,b,c,d = tu  # 解压元组
print(a,b,c,d)
# =>1 2 3 4
a,b,c,d = se  # 解压集合
print(a,b,c,d)
# =>1 2 3 4