Python基础语法笔记

 第一章、基础语法

01.字面量(写在代码中的固定的值)

02.注释 

# 单行注释
"""
多行注释
"""

03.变量

 变量无类型，数据有类型

变量名 = 变量值

04.数据类型

数据类型：  type()

05.类型转换

字符串转数字：字符串中必须只能由数字

转换为字符串：  str()
转换为浮点数：  float()
转换为整数：  int()

06.标识符(类、方法、变量命名)

只允许出现：
英文、中文、数字、下划线

不能使用数字开头

关键字：

07.运算符

 

08.字符串

字符串定义

三种定义方式：
单引号定义    name='   '
双引号定义	 name="   "
三引号定义 	 name="""          """

注意：引号嵌套。

 字符串拼接

加号  +
仅限于字符串类型本身 进行拼接

字符串格式化

方式一：
占位符   % 
	%s 、%d 、%f
多个变量时，按顺序书写

方式二：
   print(f" xxxx{变量},xxxxx{变量}")

格式化精度控制

m.n
	m表示宽度
	n表示小数点精度

• m比数字本身宽度还小时，m不生效

表达式进行字符串格式化

• f “{表达式}”
• "%s \ %d \ %f " %(表达式，表达式)

09.数据输入

• 数据输入： input()
• 键盘输入的数据，永远都是 字符串类型

第二章、判断语句

01. 布尔类型和比较运算符

布尔类型的字面量：
	True False
定义：
	变量名= 布尔类型的字面量

02. if语句

if语句

if 条件 :
	条件成立时，要做的事情

​# 定义变量
age = 30

# 进行判断
if age >= 18：
    print("我已经成年了")
​

 if…else语句

if 条件 :
	条件成立执行
else :
	条件不成立执行的条件

 if…elif…else语句

if 条件1 :
	条件1成立执行
elif 条件2:
	条件2成立执行
else :
	条件都不成立执行的条件

03.判断语句的嵌套

基础语法格式：

if 条件1 :
	条件1成立执行
	
	if 条件2 :
		条件1、2满足时执行
	else :
		条件1满足、条件2不满足时
else :
	条件1 不满足

04.判断语句综合案例

# 案例需求：
#     定义一个数字（1-10，随机产生），通过3次判断来猜出来数字
# 案例要求：
#     每次猜不中，会提示大了或小了

# 定义一个随机变量
import random
num = random.randint(1, 10)

guess_num = int(input("请输入猜的数："))

if guess_num == num:
    print("第一次就猜中了")
else:
    if guess_num > num:
        print("大了")
    else:
        print("小了")
    guess_num = int(input("请输入猜的数："))
    if guess_num == num:
        print("第二次就猜中了")
    else:
        if guess_num > num:
            print("大了")
        else:
            print("小了")
        guess_num = int(input("请输入猜的数："))
        if guess_num == num:
            print("第三次才猜中")
        else:
            print("三次都没有猜中")
print(num)

第三章、循环语句

01. while循环基础语法

while 条件 :
	条件满足时，做的事...

02.while 循环的嵌套

while 条件 :
	条件满足时，做的事...
	while 条件 :
		条件满足时，做的事...

03. for循环

基础语法

for 临时变量 in 待处理数据集 :
    循环满足条件时执行的代码

字符串遍历

for x in name_str :
    print(x)

range语句

变量作用域

04.for循环的嵌套

for 临时变量 in 待处理数据集 :
    循环满足时执行
    for 临时变量 in 待处理数据集 :
 	   循环满足时执行

 05. 循环中断：continue 和 break

• continue：用于中断本次循环，直接进入下次循环
• break：用于直接结束循环（多层循环时，跳出一层）

06.循环语句综合案例

# 某公司，账户余额有1w元，给20名员工发工资。
#     员工编号从1到20，从编号1开始，依次领取工资，每人可领取1000元
#     领工资时，财务判断员工的绩效分（1-10）（随机生成），如果低于5，不发工资，换下一位
#     如果工资发完了，结束发工资。

money = 10000
for i in range(1, 21):
    import random
    score = random.randint(1, 10)

    if score < 5:
        print(f"员工{i}绩效分{score},不满足，不发工资")
        continue

    if money >= 1000:
        money -= 1000
        print(f"员工{i}绩效分{score},满足条件，发放工资1000，账户余额{money}")
    else:
        print(f"余额{money}不足以发放工资，下个月再来")
        break

第四章、函数

函数是：

    组织好的、可重复使用的、用来实现特定功能的代码段

使用函数的好处是：

    将功能封装在函数内，可供随时随地重复使用

    提高代码的复用性，减少重复代码，提高开发效率

01.函数的定义

def 函数名 (传入参数) :
	函数体
    return 返回值

调用

函数名(传入参数)

02.函数的参数 

 03.函数的返回值

def add(a, b):
    result = a + b
    return result

r = add(1, 2)
print(r)

语法

def 函数(参数...):
    函数体
    return 返回值

变量 = 函数(参数)

None类型

 04.函数的说明文档

写在函数体之前，通过多行注释的形式，对函数进行说明解释

def func(x, y):
    """
    函数说明
    : param x :形参x的说明
    : param y :形参y的说明
    : return  :返回值的说明
    """
    函数体
    return 返回值

05.函数的嵌套调用

        在一个函数中调用了另一个函数

 06.变量的作用域

global关键字
    可以在函数内部声明变量为全局变量

07.函数综合案例

# 定义一个全局变量：money，用来记录银行卡余额（默认5000000）
# 定义一个全局变量：name，用来记录客户姓名（启动程序时输入）
# 定义如下的函数
#   查询余额函数
#   存款函数
#   取款函数
#   主菜单函数
# 要求：
# 程序启动后要求输入客户姓名
# 查询余额 存款 取款后都会返回主菜单
# 存款取款后，都应显示一下当前余额
# 客户选择退出或输入错误，程序会退出，否则一直运行

# 定义全局变量：money name
money = 5000000
name = None
# 要求客户输入姓名
name = input("请输入你的姓名：")

# 定义查询函数
def query(show_header):
    if show_header:
        print("-----------查询余额-----------")
    print(f"{name},你好，你的余额剩余：{money}元")

# 定义存款函数
def saving(num):
    global money
    money += num
    print("-----------存款-----------")
    print(f"{name},你好，你存款{num}元成功")

    query(False)

# 定义取款函数
def get_money(num):
    global money
    money -= num
    print("-----------取款-----------")
    print(f"{name},你好，你取款{num}元成功")

    query(False)

# 定义主菜单函数
def main():
    print("-----------主菜单-----------")
    print(f"{name},你好，请选择操作：")
    print("查询余额\t[输入1]")
    print("存款\t\t[输入2]")
    print("取款\t\t[输入3]")
    print("退出\t\t[输入4]")
    return input("请输入你的选择：")

# 设置无限循环，确保程序不退出
while True:
    keyboard_input = main()
    if keyboard_input == "1":
        query(True)
        continue
    elif keyboard_input == "2":
        num = int(input("你要存多少钱？请输入："))
        saving(num)
        continue
    elif keyboard_input == "3":
        num = int(input("你要取多少钱？请输入："))
        get_money(num)
        continue
    else:
        print("程序退出")
        break

第五章、数据容器

01.数据容器

 02.list（列表）

列表的定义格式

基本语法

# 字面量
[元素1, 元素2, 元素3, ...]

# 定义变量
变量名 = [元素1, 元素2, 元素3, ...]

# 定义空列表
变量名 = []
变量名 = list()

列表内的每一份数据，称之为元素

元素的数据类型没有任何限制。

列表的下标索引

列表的常用操作

列表的查询功能(方法)

    查询某元素的下标：   
        列表.index(元素)

列表的修改功能(方法)

    修改特定位置(索引)的元素值：  
        列表[下标] = 值

    插入元素：
        列表.insert(下标,元素)    在指定的下标位置，插入指定的元素
 
    追加元素：
        列表.append(元素)         将指定元素，追加到列表的尾部

	追加元素方式2：
	    列表.extend(其他数据容器)  将其他数据容器的内容取出，依次追加到列表尾部
    
    删除元素：
        del 列表[下标]  
        列表.pop(下标)

    
    删除某元素在列表中的第一个匹配项：	
        列表.remove(元素)

    清空列表内容：   
        列表.clear()

列表的查询功能(方法)

    统计某元素在列表内的数量：    
        列表.count(元素)

    统计列表内，有多少元素：	
        len(列表)                可以得到一个int数字，表示列表内的元素数量

 03.list（列表）的遍历

while循环

index = 0
while index < len(列表):
    元素 = 列表[index]
    对元素进行处理
    index += 1

for循环

for 临时变量 in 数据容器:
    对临时变量进行处理

04. tuple（元组）

元组同列表一样，都是可以封装多个、不同类型的元素在内。

但最大的不同点在于：

        元组一旦定义完成，就不可修改

定义元组

# 定义元组字面量
(元素, 元素, 元素, ...)

# 定义元组变量
变量名称 = (元素, 元素, 元素,  ...)

#定义空元组
变量名称 = ()         # 方式1
变量名称 = tuple()    # 方式2

# 定义单个元素的元组  (必须在后面加上逗号)
t = ("xxx" ,)

元组的相关操作

 遍历

while遍历：

index = 0
while index < len(元组):
    print(元组[index])
    index += 1
    
for遍历：

for element in 元组:
    print(element)

元组总结

05.str（字符串）

不可修改    

# 通过下标索引取值(可正可负)
字符串[index]

字符串的常用操作：

    查找特定字符串的下标索引值：
        字符串.index("字符串")

    字符串的替换：
        字符串.replace(字符串1, 字符串2)
        将字符串内的全部字符串1替换为字符串2
        注意：不是修改字符串本身，而是得到了一个新的字符串

    字符串的分割：
        字符串.split(分隔符字符串)
        按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
        注意：字符串本身不变，而是得到了一个列表对象

    字符串的规整操作：
        字符串.strip()           #去前后空格
        字符串.strip(字符串)     #去前后指定字符串

    统计字符串内某字符串出现的次数：
        字符串.const("字符")

    统计字符串的字符个数：
        len(字符串)

数据容器(序列)的切片

06.set（集合）

集合的定义

        元素不允许重复，内容无序

# 定义集合字面量
{元素, 元素, ...}
# 定义集合变量
变量名 = {元素, 元素, ...}
# 定义空集合
变量名 = set()

 集合的常用操作

修改：

    添加新元素：
        集合.add(元素)        将指定元素，添加到集合内
    
    移除元素：
        集合.remove(元素)        将指定元素，从集合内移除

    从集合中随机取出一个元素：
        集合.pop()

    清空集合：
        集合.clear()

    取两个集合的差集：
        集合1.difference(集合2)   取出集合1和集合2的差集(集合1有而集合2没有的)

    消除两个集合的差集：
        集合1.difference_update(集合2)    在集合1内，删除和集合2相同的元素

    两个集合合并为一个集合：
        集合1.union(集合2)        得到新集合，集合1，2不变

    统计集合元素的数量：
l       len(集合)

    集合遍历(不能用while循环)：
        for element in 集合:
            print(element)  

集合的特点

07.dict（字典、映射）

字典的定义

# 定义字典字面量
{key: value, key: value, ...}

# 定义字典变量
my_dict = {key: value, key: value, ...}

# 定义空字典
my_dict = {}        方式1
my_dict = dict()    方式2

 字典数据的获取

# 通过key值来取得对应的value
字典[key]

字典的嵌套

dict = {
    "key1": {
        "key11":value11,
        "key12":value12,
        "key13":value13,
        ......
    },
    "key2":{
        "key21":value21,
        "key22":value22,
        "key23":value23,
        ......
    },
    ......
}

        从嵌套字典中获取数据：

        字典[key1][key12]

字典的常用操作

# 新增元素
dict1[key] = value

# 更新元素
dict1[key] = value    #该key已存在于字典中

# 删除元素
dict1.pop(key)

# 清空字典
dict1.clear()

# 获取全部的key
dict1.keys()

# 遍历字典
    # 方式一：
    for key in keys:
        print(dict1[key])
    # 方式二：
    for key in dict1:
 	    print(dict1[key])

# 统计字典内的元素数量
len(dict1)

字典的特点

08.数据容器对比总结

09.数据容器的通用操作

 

        reverse = True 表示反转排序

10.拓展：字符串大小的比较 

第六章、函数进阶

01.函数多返回值 

# 按照返回值的顺序，写对应顺序的多个变量接收即可
# 变量之间用逗号隔开
# 支持不同类型的数据return

def test_return():
    return 1, 2

x, y = test_return()
print(x)    # 结果1
print(y)    # 结果2

02.函数多种传参方式

位置参数

# 调用函数时根据函数定义的参数位置来传递函数

def user_info(name, age, gender):
    print(f"您的名字是{name}, 年龄是{age}, 性别是{gender}")

user_info("TOM", 20, "男")

# 传递的参数和定义的参数的顺序及个数必须一致

关键字参数

# 函数调用时通过“键=值”形式传递参数

def user_info(name, age, gender):
    print(f"您的名字是{name}， 年龄是{age}， 性别是{gender}")

# 关键字传参
user_info(name="小明", age=20, gender="男")
# 可以不按照固定顺序
user_info(age=20, gender="男", name="小明")
# 可以和位置参数混用，位置参数必须在前，且匹配参数顺序
user_info("小明", age=20, gender="男")

缺省参数

# 缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默                                            
  认参数的值

def user_info(name, age, gender="男"):
    print(f"您的名字是{name}， 年龄是{age}， 性别是{gender}")

user_info("TOM", 20)
user_info("ROSE", 18, "女")

# 如果为缺省函数传值则修改默认参数值

不定长参数

# 不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数的场景
# 类型：
#     1.位置传递
#     2.关键字传递

# 位置传递
def user_info(*args):
    print(args)

# ("TOM", )
user_info("TOM")
# ("TOM", 18)
user_info("TOM", 18)
# 注意：
#     传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组
#     args是元组（tuple）类型


# 关键字传递
def user_info(**kwargs):
    print(kwargs)

# {"name": "TOM", "age": 18, "id": 110}
user_info(name="TOM", age=18, id=110)

# 注意：
#     参数是“键=值”形式的情况下，所有的“键=值”都会被kwargs接收，同时会根据
#     “键=值”组成字典

03.匿名函数

函数作为参数传递

def test_func(compute):
    result = compute(1, 2)
    print(result)

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

test_func(compute)       # 结果：3

lambda匿名函数

# 匿名函数定义语法：

lambda 传入参数: 函数体(一行代码)

第七章、文件操作

01.文件的编码

02.文件的读取

open()打开函数

# 示例代码：
f = open("python.txt", "r", encoding="UTF-8")
# encoding的顺序不是第三位，所以不能用位置参数，用关键字参数直接指定

mode常用的三种基础访问模式

读操作相关方法 

 操作汇总

03.文件的写入

写操作快速入门

04.文件的追加

追加写入操作快速入门

05.文件操作综合案例

# 打开文件得到文件对象，准备读取
fr = open("D:bill.txt", "r", encoding="UTF-8")
# 打开文件得到文件对象，准备写入
fw = open("D:bill.txt.bak", "w", encoding="UTF-8")
# for循环读取文件
for line in fr:
    line = line.strip()
    # 判断内容，将满足的内容写出
    if line.split(", ")[4] == "测试":
        continue    # 进入下一次循环
    # 将文件写出去
    fw.write(line)
    # 由于前面对内容进行了strip()的操作，所以要手动的写出换行符
    fw.write("\n")

# close2个文件对象
fr.close()
fw.close()      # 写出文件调用close()会自动flush()

第八章、模块、异常与包

01.了解异常

异常演示

02.异常的捕获方法

捕获常规异常

基本语法：
try:
    可能发生错误的代码
except:
    如果出现异常执行的代码

捕获指定异常

基本语法：
try:
    print(name)
except NameError as e:
    print("name变量名称未定义错误")

捕获多个异常

当捕获多个异常时，可以把要捕获的异常类型的名字，放到except后，并使用元组的方式进行书写
try:
    print(1/0)
except (NameError, ZeroDivisionError):
    print('ZeroDivision错误...')

异常else

else表示的是如果没有异常要执行的代码。
try:
    print(1)
except Exception as e:
    print(e)
else:
    print('我是else，是没有异常的时候执行的代码')

异常的finally

finally表示的是无论是否异常都要执行的代码，例如关闭文件。
try:
    f = open('test.txt', 'r')
except Exception as e:
    f = open('test.txt', 'w')
else:
    print('没有异常，真开心)
finally:
    f.close()

03.异常的传递

04.Python模块

什么是模块

模块(Module)，是一个 Python 文件，以.py结尾. 模块能定义函数，类和变量，模块里也能包含可执行的代码
 
模块的作用：
python中有很多各种不同的模块，每个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块
我们可以认为一个模块就是一个工具包，每一个工具包中都有各种不同的工具供我们使用进而实现各种不同的功能

大白话:模块就是一个Python文件，里面有类、函数、变量等，我们可以拿过来用(导入模块去使用)

模块的导入方式

模块在使用前需要先导入 导入的语法如下
[from 模块名] import [模块 | 类 | 变量 | 函数 | *] [as 别名]

常用的组合形式如:
import 模块名
from 模块名 import 类、变量、方法等
from 模块名 import *
import 模块名 as 别名
from 模块名 import 功能名 as 别名

import模块名

基本语法:
import 模块名
import 模块名1，模块名2

模块名.功能名()

案例:导入time模块
# 导入时间模块
import time

print("开始")
# 让程序睡眠1秒(阻塞)
time.sleep(1)
print("结束")

from 模块名 import 功能名

基本语法
from 模块名 import 功能名
功能名()

案例:导入time模块中的sleep方法
# 导入时间模块中的sleep方法
from time import sleep

print("开始")
# 让程序睡眠1秒(阻塞)
sleep(1)
print("结束")

from 模块名 import *

基本语法:
from 模块名 import *

功能名()

案例:导入time模块中所有的方法
#导入时间模块中所有的方法
from time import *

print("开始")
# 让程序睡眠1秒(阻塞)
sleep(1)
print("结束")

as定义别名

基本语法:
# 模块定义别名
import 模块名 as 别名

#功能定义别名
from 模块名 import 功能 as 别名

# 模块别名
import time as tt

tt.sleep(2)
print('hello')

# 功能别名
from time import sleep as sl

sl(2)
print('hello')

制作自定义模块

05.Python包

什么是Python包

快速入门

导入包

06.安装第三方Python包

安装第三方包-pip

pip的网络优化

安装第三方包-PyCharm

第九章、Python基础综合案例 数据可视化-折线图可视化

01.json数据格式

什么是json

JSON是一种轻量级的数据交互格式。可以按照JSON指定的格式去组织和封装数据
JSON本质上是一个带有特定格式的字符串

主要功能: json就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互.

json有什么用

各种编程语言存储数据的容器不尽相同,在Python中有字典dict这样的数据类型，而其它语言可能没有对应的字典
为了让不同的语言都能够相互通用的互相传递数据，JSON就是一种非常良好的中转数据格式。

json格式数据转化

# json数据的格式可以是:
{"name":"admin", "age":18}
# 也可以是:
[{"name":"admin","age":18},{"name":"root","age":16},{"name":"张三","age":20}]

Python数据和Json数据的相互转换

# 导入json模块
import json

# 准备符合格式json格式要求的python数据
data =[{"name":"老王","age": 16},{"name":"张三","age": 20}]

# 通过json.dumps(data)方法把python数据转化为了json数据
data = json.dumps(data)

# 通过json.loads(data)方法把json数据转化为了python数据
data = json.loads(data)

02.pyecharts模块介绍

03.pyecharts快速入门

基础折线图

# 导包，导入Line功能构建折线图对象
from pyecharts.charts import Line

# 得到折线图对象
line = Line()
# 添加X轴数据
line.add_xaxis(["中国", "美国", "英国"])
# 添加y轴数据
line.add_yaxis("GDP", [30, 20, 10])
# 生成图表
line.render()

04.数据处理

05.创建折线图