python简单入门

python简单入门

0.0 地址链接

1. 官网

官网https://www.python.org/

2. 下载地址

官网下载地址https://www.python.org/

3. 官方文档

官方文档https://www.python.org/doc/

第一章 入门

1. python解释器

基本原理 ：计算机只认识二进制 0 1

python代码 => python解释器 => 二进制代码 => 执行

安装python环境，本质上就是安装python解释器

2. 基础语法

2.1 常见数据类型

1. 数字
   • 整型 int 也就是整数，如10 -10等
   • 浮点型 float 也就是小数，如3.14 0.66等
   • 复数 complex 也就是实数和虚数的组合，如5+3i等
   • 布尔型 bool 也就是真假类型，真为True，假为False
2. 字符串
3. 列表list 有序可重复
4. 字典dict 键值对，键唯一
5. 元祖tuple 元素不可变
6. 集合set 无序不重复

变量的定义，格式：

变量名=变量值，如count=20；，l=list()，dic={'a':10,'b'=666}等

使用type()查看数据类型，如type(10)显示<class 'int'>

变量最好做到见名知意，也就是看到变量名能大概猜到表示什么，比如stock_price表示股票价格，而a b c x等等，用在项目中就不那么舒服了

2.2 强制类型转换

1. 字符串转换为数字
   也就是说，起初类似str=“123”，但类型是字符串类型，不能与数字进行运算，需要强制转换为数字
   对于字符串转数字，要求字符串的内容都是数字，如"123"，"666"等，不能掺杂其他非数字类型，比如"123a"，"66b5"等

# 转换为整型
num=int(str);
# 或者，转换为浮点型
num=float(str);

2. 数字转换为字符串
   不希望数字参与运算，转换为字符串类型。

num=10
# 转换为字符串类型
s=str(num)

2.3 注释

1. 单行注释
   #号开头 如# 单行注释
   注意# 号后有一个空格（规范）
2. 多行注释
   使用三个 " 包围，如：

"""
多行 
注释
"""
code

3. 快捷键 ctrl + /
   对需要注释的代码，选中后，按下快捷键即可

2.4 运算符

运算符	描述
+	加法运算
-	减法运算
*	乘法运算
/	除法运算（结果带小数）
//	取整除（结果下取整）
%	取余运算
**	指数运算
=	赋值运算
复合运算	如a=5;a+=1;，相当于a=5;a=a+1;，也就是说a+=1相当于a=a+1，a*=5相当于a=a*5，以此类推

2.5 字符串

2.5.1 字符串的定义

三种方式

1. 单引号接收，如 name=‘jack’
2. 双引号接收（常用），name=“jack”
3. 三引号接收，name=“”“jack”“”

2.5.2 字符串拼接

使用+来拼接多段字符串
如s = "abc" + "天气不错" + "666"，结果为s = "abc天气不错666"

2.5.3 格式化字符串

用在需要拼接的字符串太多，使用占位符先占个位，再补(支持数字类型和字符串类型拼接)

name = "jack"
age = 20
hobby = "sleeping"

res="the man %s is %s years old and he likes %s" % (name, age, hobby)
# %表示这是个占位符 s表示需要占位的内容
# the man jack is 20 years old and he likes sleeping
# 代码中数字20，先转换成了字符串，后参与拼接

常用的三种占位

1. %s 将内容转换为字符串后拼接
2. %d 将内容转换为整型后拼接
3. %f 将内容转换为浮点型后拼接

2.5.4 精度格式化

使用m.n格式化数值的整数部分和小数部分

若num = 123.4567
%5d为[空格][空格]123
%5.2f为[空格][空格]123.46,小数部分进行四舍五入，若不限制整数部分的宽度，可写成%.2f

2.5.5 快速格式化

格式：f"内容{变量}"，如

name = "jack"
age = 20

res = f"{jack} is {age} years old"

即可完成快速格式化

快速格式化不关心数据类型，也不做精度控制

2.6 数据输入

print()用来输出数据
input()用来输入数据，读取键盘输入

格式：
value = input()

input输入的全部作为字符串类型

2.7 条件与循环

# 条件
if 条件1为真:
    code1
elif 条件2为真:
    code2
else:
    code3
    
# for 循环 举个例子，遍历从0到9的十个数
for i in range(10):
    print(i)

# while 循环
while 条件为真:
    code

2.8 condition与break

condition用于退出当前的循环，但继续下一次循环

break跳出整个循环，嵌套循环中跳出内循环

2.9 函数

def 函数名(参数):
    函数体code
    [return 返回值]

"""
对第一章的一些简单注释
极简模式
"""
# 1. 数字
# - 整型 int 也就是整数，如10 -10等
a = 10
# - 浮点型 float 也就是小数，如3.14 0.66等
b = 3.14
# - 复数 complex 也就是实数和虚数的组合，如5+3i等
c = complex(5, 3)
# - 布尔型 bool 也就是真假类型，真为True，假为False
d = True
# 1.3. 字符串
str = "一串字符串"
# 3. 列表list 有序可重复
l = list([1, 2, 3])
# 4. 字典dict 键值对，键唯一
dic = dict({'a': 1, 'b': 2})
# 5. 元祖tuple 元素不可变
tup = (1, 2, 3)
# 6. 集合set 无序不重复
s = set("set_content")

print(type(a))
print(type(tup))
print(type(s))
"""
<class 'int'>
<class 'tuple'>
<class 'set'>
"""

print(a/b)
print(a//b)
"""
3.184713375796178
3.0
"""

name = "zhangsan"
age = 20

res = f"{name} is {age} years old"


print("你叫什么名字？")
name = input()
# 也可以两行并一行为：name = input("你叫什么名字？")
print(f"你好，{name}!")

3. 数据容器

可以存储若干数据的容器，存储数据的类型可以不唯一

3.1 列表list

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

3.1.1 创建列表

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可

list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]

3.1.2 访问列表数据

使用下标索引来访问列表中的值，或者使用下标索引来访问列表中的值

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]

# 加入元素
list2.append("abc") # 尾加

同样，更新元素就是访问到元素后，重新赋值：list[0] = 666

3.1.3 删除元素

可以使用 del 列表[下标] 的方式

或者 列表.remove(元素) 的方式

一次只能删一个元素

3.1.4 列表的截取

>>>L = ['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>

如果是从第一个元素向后选取，则第一个元素下标为0，最后一个元素下标为列表长度-1

如果是从最后一个元素向前来看，则最后一个元素下标为-1，第一个元素下标为-列表长度，需要注意的是也是从左向右选取

names = ["a", 2, "bb", "c"] # 下标分别为 0 1 2 3 或者是 -4 -3 -2 -1
print(names[0:2]) # ['a', 2]
print(names[-4:-2]) # ['a', 2]

# 或者，规定逆向
print(names[-2:-4:-1]) # ['bb', 2]

3.1.5 列表的遍历

list = ['html', 'js', 'css', 'python']

# 1
for i in list:
    print(list.index(i), i)

# 2
for i in range(len(list)):
    print(i, list[i])

# 3
for i, val in enumerate(list):
    print(i, val)
    
# 4 
i = 0
while i < len(list):
    print(i, list[i])
    i += 1

3.2 字符串str

字符串是 Python 中最常用的数据类型

可以使用引号 ( ’ 或 " ) 来创建字符串

3.2.1 创建字符串

为变量分配一个值即可

s = "abc"

text = "Hello Wolrd!"

3.1.3 访问字符串的值

使用下标的方式访问
text[0]是H，text[-1]是!

也可以通过下标来切割字符串
text[0:5]值为Hell

3.2.3 字符串拼接

使用+来拼接若干段字符串

s2 = s + " " + text，s2的值为abc Hello Wolrd!

3.3 字典dict

使用key:value键值对的方式存储数据

3.3.1 创建字典

dic1 = dict()
dic2 = dict({'a':1,'b':2})

3.3.2 获取字典的值

使用dic2['a']或者dic2.get('a')的方式根据key来获取value的值

3.3.3 更新字典

根据字典的key获取到值后，重新赋值即可
dic2['a'] = 10

3.3.4 添加数据

使用dic[]的方式，如dic2['c'] = 3，字典中没有键为c的键值对，会自动添加一对c : 3

3.3.5 字典的遍历

# 1
for key,value in dic2.items():
    print(key,value)

# 2 
for i in dic2.keys():
    print(i,dic2[i]) # or print(i,dic2.get(i))

3.4 元组tuple

元组的元素不能修改

只需要在括号中添加元素，并使用逗号隔开即可创建元组

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
tup3 = "a", "b", "c", "d"

可根据下标来访问数据，但元组创建后，就不可以更改其数据了

3.5 集合 set

集合中的元素不可重复

使用花括号来创建集合

set1 = {'a', 'b', 'c', 4}

一般可用于对列表 list 等容器中的数据去重

4. 模块

python的模块就是一个或一组python代码文件,内有类 、函数、 变量等，可以导入文件中所有方法或者所需的部分方法

# 格式： [from 模块名] import [模块、类、变量、函数、*] [as 别名]
import numpy as np
# 使用np包的方法
np.xxx

# 从time包导入sleep方法
from time import sleep
# 睡眠10秒
sleep(10)

模块导入部分一般写在代码文件的开头部分

自定义模块的导入

在text_my_module.py中导入my_module1.py模块的test方法：

模块名也就是文件名，需要符合命名规范

5. 包

包本质上就是一个文件夹，里面有若干python文件，还有一个__init__.py文件，标志这是一个包，如果没有__init__.py文件，那就是一个普通文件夹

通过from 包名.文件名 import 方法/*或者from 包名 import 文件名的方式导入

其中的__init__.py文件可以使用__all__来控制import *的范围，只能控制*的范围，如果不需要控制效果，__init__.py文件可以为空（如果想要这是个包，而不是普通文件夹，__init__.py文件必须要存在，可以内容为空）

第二章 函数

格式：

def 函数名（参数）：
    函数体
    [return 返回值]

如：

def add(x, y):
    result = x + y
    return result

1. 函数多返回值

在函数中，执行 return 就会退出函数，因此如果有多个返回值，不能用：

# 反例
def add(x, y):
    result1 = x + y
    result2 = x * y
    return result1
    # return result2 将不会被执行
    return result2

的方式，而应该采用

def add(x, y):
    result1 = x + y
    result2 = x * y
    return result1， result2

的方式，在执行完函数，接收返回值时，可以这样接收

# x, y 为传入的参数
# res1 为接收的加法结果，res2 为接收的乘法结果
res1, res2 = add(x, y)
# 如果只需要接收其部分返回值，如只需要接收加法，不接收乘法，使用下划线 _ 来占位即可
res, _ = add(x, y)

# 对于函数的返回值，数量不限，数据类型不限，注意接收时对位
de test():
    return 1, "a", True, 0.666

2. 多种传参方式

2.1 位置参数

也就是在调用函数传递参数时，按函数的形参顺序传入实参

def add(num1, num2):
    return num1 + num2
    
x, y = 1, 2
sum = add(x, y)

2.2 关键字参数

也就是在调用函数传递参数时，通过键值对的形式，指定形参名来传入参数，因此顺序就无所谓了

def add(num1, num2):
    return num1 + num2
    
x, y = 1, 2
sum = add(num1=x, num2=y)
# 如果没有指定形参，就是位置参数
sum = add(x, num2=y)
# 关键字参数的位置无所谓
sum = add(num2=y, num1=x)

2.3 缺省参数

也就是函数的形参给定了默认值，当本该实参传递但并没有传入某个参数时，采用默认值

def add(num1 = 10, num2 = 20):
    return num1 + num2
    
x = 1
sum = add(num1=x)
# 没有指定 num2 的值，使用函数的默认参数 num=20

注意：默认值的设置，其在函数中定义的位置必须在最后，如：def add(num1,num2=10)，而不能出现 def add(num1=10,num2) 的情况
理解起来可以是，从后向前定义缺省，从后向前的缺省定义是连续的

2.4 不定长参数

传入参数的数量不确定时，采用不定长参数的方法

def add(*args):
    sum = 0
    for i in args:
        sum += i
    return sum
add(10,20,30,40)

所有传入参数被 *args 收集，合并为一个元组，不定长参数传递的数量可以是 0 个、1 个、10 个等，数量不限、类型不限

关键字传递不定长

def ope(**kwargs):
    sum = 0
    for x, y in kwargs.items():
        print(x, y)
kwargs(name='Tom',age=20,gender="Male")

关键字传递不定长采用键值对的形式传入参数

上面的 args 和 kwargs 可以任意命名，只不过出于规范或者是习惯，通常命名为 args 和 kwargs

3. 匿名函数

使用def定义函数，函数有其名称，如def add();，可基于名称重复使用

使用lambda定义函数，函数没有名称，仅可使用一次，或者叫，只需要使用一次，称为匿名函数

格式为lambda 参数:函数体

匿名函数的函数体，只能写一行

以

def add(x,y):
    return x+y

为例，使用lambda创建匿名函数为：lambda x,y:x+y

lambda的匿名函数不用写return语句，默认return

lambda的匿名函数的作用范围仅在本次的调用中

第三章 文件

1. 文件编码

编码记录内容和计算机二进制之间的转换关系（计算机只认识二进制）

简体中文常用gbk编码

国际通用utf-8编码（万国码）

用什么编码就要用什么解码，否则乱码

2. 文件读取

2.1 open()

使用open()方法打开一个已存在的文件，或者新建一个文件

格式：open(filename,mode,..,encoding)

常用为这三个参数
filename为需要打开文件的文件名
mode为文件的访问模式：读？写？
encoding为打开文件所使用的编码格式
注意：encoding并不是顺序上第三位，需要使用关键字传参的方式

其中，mode 的选项有：

模式	含义
r	只读，文件不存在则报错
r+	可读可写，读取时文件不存在则报错，写入时覆盖
w	只写，文件不存在则创建，文件存在则覆盖
w+	可读可写，文件不存在则创建，存在则覆盖
a	可写，文件不存在则创建，存在则追加
a+	可读可写，文件不存在则创建，存在则追加

f = open("./file.txt",'r',encoding='utf-8')

# 读取文件，方式三选一即可,三选一
# 1. read()
data = f.read()
# 2. readlines()
data = f.readlines()
# 3. readline()
data=list()
line = f.readline()
while line:
    data.append(line)
    line = f.readline()
# 或者使用for循环的方法
data = list()
for line in f:
    data.append(line)
    
# 使用open记得关闭文件流
f.close()

2.2 with open()

使用open()读取文件需要注意读取文件后手动关闭流（文件对象占用系统资源），使用with open()的方式，在读取文件后自动关闭流，更方便

with open("./file.txt",'r',encoding='utf-8') as f:

# 读取文件，方式三选一即可,三选一
# 1. read()
data = f.read()
# 2. readlines()
data = f.readlines()
# 3. readline()
data=list()
line = f.readline()
while line:
    data.append(line)
    line = f.readline()
# 或者使用for循环的方法
data = list()
for line in f:
    data.append(line)
    
# 不需要再手动关闭文件流

3. 文件写入

模式	含义
w	只写，文件不存在则创建，文件存在则覆盖
w+	可读可写，文件不存在则创建，存在则覆盖

f = open("file.txt",'w',encoding='utf-8')
# 写入内容
f.write("hahaha")
# 将所有内容写完后，从内存缓冲区刷到硬盘中
f.flush()
# 关闭文件流
f.close()# close()方法内置了flush，所以关闭文件也可以不使用flush()

# 或者用with open
with open("file.txt",'w',encoding='utf-8') as f:
    # 写入内容
    f.write("hahaha")

4. 文件追加

模式	含义
a	可写，文件不存在则创建，存在则追加
a+	可读可写，文件不存在则创建，存在则追加

# 将写入操作的'w'换为'a'即可实现追加
with open("file.txt",'a',encoding='utf-8') as f:
    # 写入内容
    f.write("hahaha_2")

第四章 异常

程序执行出错的语法或逻辑错误,比如打开文件时的文件未找到异常FileNotFoundError，除以0的ZeroDivisionError等。

1. 异常捕获

程序不可能完美运行（偏向大项目），使用异常的捕获来减少程序崩溃

在可能发生异常的地方进行捕获，能够在真正发生异常的时候提供解决方案

try:
     可能发生错误的代码
catch [异常 as 别名]:
     如果出现异常则执行的代码
[else:]
	未出现异常的行为
[finally:]
	最终执行的行为

# 比如打开并不存在的文件test.txt
try:
	# "test.txt"不存在
	f = open("test.txt",'r',encoding='utf-8')
catch:
	# 捕获到文件不存在异常，则以写入的方式打开
	f = open("test.txt",'w',encoding='utf-8')

捕获多个异常

# 一组try-catch可以捕获多种异常，如
try:
	# 1除以0，除零异常
	1/0
	# 未定义name变量
	print(name)
catch (NameError,ZeroDivisionError) as e:
	print("捕获到了异常")
	print(e)

捕获所有异常

# 一组try-catch可以捕获多种异常，如
try:
	# 1除以0，除零异常
	1/0
	# 未定义name变量
	print(name)
catch Exception as e:
	print("捕获到了异常")
	print(e)
# 或者是省略Exception
catch:
	print("捕获到了异常")

else和finally

# 一组try-catch可以捕获多种异常，如
try:
	# 1除以0，除零异常
	1/0
	# 未定义name变量
	print(name)
catch Exception as e:# 捕获到异常则执行
	print("捕获到了异常")
	print(e)
else:# 没有捕获到异常则执行
	print("没有异常出现")
finally:# 不管有没有捕获到异常都执行
	print("最终执行")
# 其上的try-catch是必要的，else-finally是可选的

如果有异常：try->execption->finally
如果没有异常：try->else->finally

2. 异常传递

在main()中调用了func2()方法，在func2()中调用了func1()方法，如果func1()中出现了异常，但是func1()中并没有进行异常的捕获，则异常会传递给func2()，如果func2()中也没有对异常进行捕获，则异常传递给main()，如果main()中还是没有进行异常的捕获，那就是正常情况下程序崩了的场景