Python基础--PART1

最近闲来无事，学习使用Python也有好几年了，一直没有系统的总结，现在有时间就写一写个人的一些拙见。

PART1. 核心语法(基础语法)

1. 变量

1.1 变量的定义

变量就是可变的量，对于一些有可能会经常变化的数据，我们需要使用一个符号，这样才能计算中使用它，就像我们在小学时学过的一元方程中的"x"一样。比如说，我们在控制台内输入：

x = "world"

这样我们就新定义了一个变量，它的值是"world"，我们稍稍修改一下Hello world的例子，这次我们使用变量x。

print("Hello", x)

运行后输出的结果和我们之前的例子是一样的，在这里，x就相当于"world"。对于变量，我们可以理解为一个带有抓手的容器，我们可以往里任何我们想放的东西，而这个抓手，就是变量名，提着这个抓手，我们可以更方便的使用容器里的东西。

name = "Smith"
print("Mr", name)
print("Mrs", name)

1.2 变量命名规则

在Python中，变量名尽量遵循一下的规则：

变量名由字母、数字和下划线组成，也就是a-z, A-Z, 0-9和_；

变量名不能以数字开头；

变量名是区分大小写的，比如a 和 A就是两个不同的变量。

# 这些都是合法的变量名
a = "hello"
MyJob = "analyst"
player1 = "姚明"
_private_name = "ss"
player1_score = 41
_ = "something"

# 下面这些都是不合法的变量名
1abc # 不能以数字开头
123
abc- # 注意这是横杠符号，不是下划线

另外，在此基础上，我们也约定了一些变量名的命名规范。比如：

普通变量一般用小写字母；

最好不要用单词加数字的方式来命名变量，尤其是没有意义的随机数字；

有两种风格的变量名：单词之间用下划线隔开；每个单词的首字母使用大写字母（也称为驼峰命名法）

注意，上面的规范只是程序员们的一种约定俗成规则，并不是Python语言的硬性要求。但是遵循了这些规范，写出来的变量名可读性更高，更有利于团队合作。

1.3 关键字

以下的这些单词都是Python的关键字，每个编程语言都有各自的关键字，它们组成了编程语言基本的语法规则，在命名的时候避免使用这些名字就行了。

False	 await	 else	 import	 pass
None 	break 	except 	in 	raise
True	 class 	finally 	is 	return
and 	continue	 for	 lambda 	try
as 	def 	from 	nonlocal 	while
assert 	del 	global 	not		with
async	 elif	 if 	or 	yield

如果你一不小心定义了一个与关键字相同的变量，代码会在运行的时候报错

True = 0
# 上面这行代码运行会输出下面的信息，提示不能给关键字赋值。
# File "<stdin>", line 1
# SyntaxError: can't assign to keyword

1.4 变量赋值

变量是可以重复使用，并且是可以修改的，由于Python的变量不需要先声明，所以变量的声明和赋值是在同一行代码完成的，比如我们上面声明的name变量。

def foo():
    pass
name = "Smith"
foo()

在这一行里，我们先定义了一个名为"name"的变量，然后给它赋值为"Smith"，这样，我们就有了一个变量"name"，它的值是"Smith"。变量必须要先声明，才能使用。如果使用了一个从未定义过的变量xxx，Python解释器会抛给你一个这样的错误：

NameError: name 'xxx' is not defined

在变量定义完成后，我们可以随意读取、修改它的值，比如：

# 定义name变量，赋值为"Smith"
name = "Smith"
print("Mr", name)

# 修改变量的值为"Jones"
name = "Jones"
print("Mr", name)

有时候，我们需要定义好几个变量，以进行计算。比如现在我想要定义三个变量，可以这样写：

#三个相同
a = b = c = 1
#三个不同
a, b, c = 1, 2, 3

1.5 变量的销毁

在Python中，我们一般无需手动的去销毁变量，Python的垃圾回收机制会帮我们处理掉那些不再使用的变量，如果我们想刻意销毁删除某个变量，可以使用del关键字。

# 销毁后，这个变量就像没有定义过一样，再使用它的话就会产生异常。
del name

2. 数据类型

三种基本的数据类型：

数值，包括整数和浮点数；

字符串；

布尔值。

2.1 数值

Python中数值有两种类型，整形(int)和浮点型(float)，通俗一点的讲，一个是不带小数点的，一个带小数点的。

# 这是一个整形
a = 100

# 这是一个浮点型变量
b = 3.14

# 整形和浮点形数值可以相互运算
# c是一个浮点型变量
c = a + b

这里面变量c还是一个浮点型，它的值是3.0，可以得出一个结论，只要有浮点数参与的运算，它的结果肯定也是浮点数。

a = 0.14
b = 3.14
c = b - a # c=3.0

2.2 字符串

我们在定义字符串时使用的都是双引号，其实Python也支持单引号，它们并没有什么区别。

如果说还有更长的字符串，类似一整段话，我们可以使用三引号。

a = "Hello"
b = 'world'
print(a, b)
# 输出的结果仍然是Hello world

cen = """Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense."""
print(cen)

当如果字符串含有特殊字符，比如双引号，我们可以加一个" \ "来进行转义。(反斜杠)

print("Buddha: \"What we think, we become.\"")
# 输出的结果是：Buddha: "What we think, we become."

2.3 布尔值

布尔值只有两个值: True 和 False

a=3
b=4
# false
print(a>b)
# true
print(a<b)

2.4 空值None

空值None是Python中的一个特殊值，它代表空值，表示“什么都没有”，None同时也是关键字。None的用处有很多，比如说你想定义一个变量，但一时还没想好给它赋什么值，甚至连它用什么类型也没决定好，这时可以先用None。

temp = None
print(temp)
# None被输出的时候显示为一个字符串"None"

2.5 类型转换

2.5.1 布尔值转换

要想把其他值转换为布尔值，需要使用一个内置函数bool()，我们在控制台按顺序输入以下的代码。

所有的非零值转换为True, 只有零值才转换为False。

# 以下值都为True
bool(1)
bool(-1)
bool(255)
bool(0.0000001)
bool(-99.99)

# 下面的值为False
bool(0)
bool(0.0)

字符串也可以转换为布尔值。

对于任何非空的字符串，转换为布尔值都是True。

# 这是一个空字符串，转换结果为False
bool("")

# 转换结果为True
bool("abc")

# 这是一个只包含一个空格的字符串，转换结果为为True
bool(" ")

空值转换为布尔值永远都是False

# 结果为False
bool(None)

2.5.2 字符串转换

使用str() 将其他类型转换为字符串

a = 18
print(type(a))
a = str(a)
print(type(a))

2.5.3 数值转换

数值转换是我们在数据分析过程中经常用到的，因为我们从任何文件中读到的数字一开始都是字符串，需要将它们转换为数值才能进行运算。如果想要把一个整数字符串转换为int类型，使用int():

num = "1"
int(num) + 1
# 如果将int()去掉，这段代码则会报错，因为num是个字符串，不能将字符串和数值进行相加。

数值的前后带有空格也可以成功转换，带有符号的数字也可以成功转换

int(" 100 ") # 结果为100
int("-1") # 结果为-1
int("+1") # 结果为1

如果想要把一个带小数点的字符串转换为float类型，使用float()：

pi = "3.1415926"
float(pi)

int类型和float类型之间也可以相互转换

int(3.14) #结果为3
int(9.9) # 结果为9   9.9并没有转换为10，小数部分精度将被丢弃，只取整数部
float(100) # 结果为100.0

如果想要四舍五入的来转换，可以使用round函数，round函数让我们可以指定要保留小数点后几位：

# 保留小数点后两位，由于第三位是1，所以结果是3.14
round(3.1415926, 2)
# 保留小数点后三位，由于第四位是5，所以结果是3.142
round(3.1415926, 3)

布尔值也可以转换为int或者float

# 恰好是数值类型转换为布尔类型的相反过程
int(True) # 结果是1
int(False) # 结果是0
float(True) # 结果是1.0
float(False)# 结果是0.0

3. 运算符

3.1 算术运算符

Python中进行数值运算需要的符号如下

运算符	描述	实例
+	加	1 + 1; a + b
-	减	10 - 5; a - b -c
*	乘	4 * 2 相当 4 × 2
/	除	4 / 2 相当于 4 ÷ 2
//	取整除	10 // 4 结果是 2
%	取模	10 % 4 相当于 10 - (10 // 4) × 4，r = a % b = a - [a//b]*b
**	指数	2 ** 3 相当于 2 * 2 * 2，也就是2的3次方
()	小括号	提高运算优先级，比如: (2 + 8) * 3

例子：

print(1 + 1)
print(10 - 5)
print(4 * 2)
print(4 / 2) # 结果是2.0，返回值为浮点数
print(10 / 3) # 结果是3.3333333333333335
print(5 / 2) # 结果是2.5，返回值为浮点数
print(5 // 2) # 结果是2，双斜杠来进行运算，返回int
print((2 + 8) * 3) # 结果是30

关于取模运算符：

当两个数能整除时，取模运算的结果为0，比如 8 % 4 的结果是0；

当0<a<b时，a % b = a，比如 3 % 8 的结果是3；

当两个数中有负数时，结果可能会跟我们预料的不同，记住这个公式就行了：a % b 就相当于a -(a // b) * b；

0不能作为除数，也不能用来取模。

3.2 算术运算符操作字符串

字符串在Python中也可以“运算”，可以理解为拼接。

print("Hello " + "world")
print("apple " + "apple " + "apple ")
print("apple " * 5)

使用加号拼接字符串时需要注意，不能将字符串与数值一起相加

print("您账户积分为：" + 500)  #达咩
print("您账户积分为：" + str(500))  #ok

3.3 赋值运算符

赋值操作其实就是在前面定义变量的时候我们都会使用等于号。

num = 1
name = "Smith"

结合运算符，我们可以做更多的赋值操作：

运算符	描述	实例
+=	加法赋值运算符	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 XX a

在日常编程中最常用的是加法赋值和减法赋值，比如设置一个计数器，每次+1

count = 0
count += 1
count += 1 # 值为2

3.4 比较运算符

比较运算符是用来运算布尔值的，将两个值放在一起比较，最后得到True或者False。

运算符	描述	实例
==	等于	100 == 100
!=	不等于	100 != 99
>	大于	2 > 1
<	小于	1 < 2
>=	大于等于	3 >= 2
<=	小于等于	2 <= 3

实例：

100 == 100 # True
100 == "abc" # False
1 != 2 # True
2 != 2 # False
3 > 3 # False
3 >= 3 # True
2 < 3 # True
2 <= 3 # True

# 不仅可以判定值，也可用于类型的判断
100 == "100" # False
100 == 50 * 2 # True
str(100) == "100" # True
1.0 != 1 # False
int(1.9) == 1 # True

3.5 逻辑运算符

真实的程序中，常常需要判断的条件是复杂的，所以我们需要逻辑运算符将多个比较运算连接起来。

运算符	逻辑表达式	描述
and	x and y	任意一个是False，结果就是False
or	x or y	任意一个是True，结果就是True
not	not x	将条件取反

实例：

# 定义两个变量
a, b = 1, 2
a > 0 and a < b # True
a % 2 == 0 or b % 2 == 0 # True
not a > b # True

# 思考
a = 0 or 100 # a=100
b = 1 or 2 # b=1

4. 流程控制

4.1 条件判断

4.1.1 if…else…

在这里要介绍两个重要的关键字，if 和 else，看它们的字面意思就能猜到它们表示“如果”… “否则”…

注意缩进

num = 3
# 通过取模运算判断num是否能被2整除
if num % 2 == 0:
	print(str(num) + "是一个偶数")
else:
	print(str(num) + "是一个奇数")

4.1.2 elif

比如说来判断一个学生的考试成绩，60分以下的为不及格，60~90分为合格，90分以上为优秀，这里面有三个条件。

score = 80
if score < 60:
	print("您的考试成绩不及格")
elif score < 90:
	print("您的考试成绩合格")

else:
	print("您的考试成绩优秀")

4.1.3 if条件嵌套

还是以学生考试成绩的例子来说，现在我们想对60_{100分的进行更细的划分，60}70分为合格，70~90分为良好，90分以上为优秀。

score = 100
if score >= 60:
	if score < 70:
		print("您的考试成绩为合格")
	elif score < 90:
		print("您的考试成绩为良好")
	else:
		print("您的考试成绩为优秀")
else:
	print("您的考试成绩不及格")

4.1.4 与逻辑运算符组合

age = 22
if age > 18 and age < 60:
	print("你已经不是个孩子啦，该去工作啦")

# 简洁版
age = 22
if 18 < age < 60:
	print("你已经不是个孩子啦，该去工作啦")

4.1.5 自动类型转换

if 和 elif 的后面总是跟着一个表达式，这个表达式的结果必须是True或者False，如果表达式运算出来的结果不是一个布尔值，则会自动将结果转换为布尔值，无论它是什么类型的值。转换的结果遵循我们之前学过的布尔转换规律。

# 试着将count的值改为1，条件则成立了
count = 0
if count:
	print("条件成立")
else:
	print("条件不成立")

0值、None 和空字符串转换为布尔值后都是False

result = None
if result:
    pass
else:
	print("什么收获都没有")

4.2 循环

4.2.1 while循环

跑圈案例

lap = 0
while lap < 10:
	lap += 1
	print("我跑完了第" + str(lap + 1) + "圈")

4.2.2 for循环

for循环可以用来遍历序列，序列指的是一个可迭代的有序的集合，比如字符串就是一个序列，下面我们用for循环来打印出一个字符串中的所有字符。

seq = "hello"
for s in seq:
	print(s)

也可以用for循环来打印一连串的数字，这里需要用到一个新的内置函数：range。

# range函数的作用就是提供一个从0到4的迭代器，而for可以遍历这个迭代器。注意是从0开始的，整个循环一共打印了5个数。
#左闭右开
for i in range(5):
	print(i)
    
# 跑圈优化
for lap in range(10):
	print("我跑完了第" + str(lap + 1) + "圈")

4.2.3 嵌套循环

既然掌握了两种循环写法，那可以把它们组合起来运用，我们来写一个例子，在控制台中打印出指定边长的长方形或者正方形图案。

# 指定长方形的宽和高
width, height = 10, 5
# 因为是从上往下开始打印，所以先遍历高度
for i in range(height):
	for j in range(width):
		print("*", end="")
	print()

**********
**********
**********
**********
**********

第一个print，end表示在打印完指定的内容后，在结尾再打印一个指定的字符串，默认每个print语句在结尾会加一个换行符"\n", 传递一个空字符串给它，表示打印完星号以后不再添加任何输出内容。

第二个print函数没有任何参数，那它会输出一个换行符。

for i in range(5):
	for j in range(i + 1):
		print("*", end="")
	print()

*
**
***
****
*****

打印出这样一个九九乘法表：

for i in range(1, 10):
	for j in range(1, i + 1):
		print("%s*%s=%s" % (j, i, i * j), end=" ")
	print()

1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

4.2.4 break和continue

有时候在循环内部，我们需要临时略过某一次循环或者干脆跳出整个循环，这时候就需要用到break和continue。

在下面这个例子中，我们使用for循环和continue来打印出10以内的所有奇数相加的式子，并求出它们的和。

total = 0
for i in range(10):
	if i % 2 == 0:
		continue
	print(i, end=" + ")
	total += i
print(" = %s" % total)

关键字break用来打断整个循环并跳出。看这个例子，给一个字符串，这个字符串是一个小数，要求打印出小数的整数部分。

s = "238.9237834829"
for i in s:
	if i == '.':
		print()
		break
	print(i, end='')

小数的整数部分都在小数点的左边，而我们遍历字符串是从左往右，所以当遇到小数点后，就停止遍历，这样就正好实现了打印这个小数的整数部分。

4.3 举个栗子

密码开锁功能是这样的，首先设定好密码，以后每次开锁的时候只要输入的数字中含有设定的密码，就视为解锁成功。这样的设定是为了防止别人的窥探，具有更高的安全性。

首先，由于涉及到了输入，先来学习一下Python内置的输入函数: input

# 这里获取的是str类型
password = input("请设置您的密码")

# 设置初始密码
password = "123"
while True:
    pwd = input("请输入您想要设置的密码：")
    # 如果没有输入任何密码，则使用初始密码作为密码
    if not pwd:
        break
    confirm_password = input("请再次输入您的密码：")
    if pwd == confirm_password:
        password = pwd
        break
    else:
        print("您两次输入的密码不一致，请重新输入。")
print("您的初始密码已设置为：" + password)
print("进入开锁程序。。。")
# 开锁
while True:
    input_pwd = input("请输入您的密码：")
# 判断输入的密码中是否包含密码
    if password in input_pwd:
        print("开锁成功！")
        break
    else:
        print("您输入的密码有误，请重新输入")