python基础 基础语法

一，基础语法

        1，打印

              茴字的多种写法，选择一个你喜欢的就好

year = 2023
month = 8
day = 19
print(f"today is {year}-{month}-{day}")
print("today is %d-%d-%d"%(year,month,day))
print("today is "+f"{year}-{month}-{day}")

        2，while语句嵌套

             直接看代码，九九乘法表

a = 1
b = 1
while a <= 9:
    b = a
    while b <= 9:
        num = a*b
        print(f"{a} * {b} = {num} \t",end = '')
        b += 1
    a+=1
    print("\n")

       3，if，elif，else嵌套

                直接看代码，猜数字判断

import random
num = random.randint(1,100)
res = input("请输入一个数字\n")
res = int(res)
while res!=num:
    if res>num:
        print("输入的值大了")
    else:
        print("输入的值小了")
    res = input("请输入一个数字\n")
    res = int(res)
print("你猜的没错",res)

        4，for循环使用案例

name = "lzhlzhlzh"
#for x in m      m是被处理的数据
#处理字符串
#数一数name里面有多少个l
res = 0
for x in name:
    if x == 'l':
        res += 1
print("字符串里面一共有%d个l"%(res))

for循环中常搭配range语句使用

name = "lzhlzhlzh"
#range语句   range(num)
#语法1  0~num-1
num = 10
for x in range(num):
    print(x)
#语法2  num1~num2-1
num1 = 1
num2 = 10
for x in range(num1,num2):
    print(x)
#语法3  num1~num2-1  step为间隔
num1 = 10
num2 = 101
step = 10
for x in range(num1,num2,step):
    print(x)

for嵌套经典案例：

#循环综合案例
#账户1w元，给20名员工发工资，每人1k
#领工资时，员工绩效分为1-10（随机生成），如果低于5，不发工资，给下一位
#工资发完了，就结束发货
import random
sum = 10000
for x in range(20):
    temp = random.randint(1,10)
    if temp < 5:
        print(f"员工{x}绩效不满足{5}，不发工资，下一位")
        continue
    else:
        print(f"员工{x}绩效满足{5}，发工资1000，下一位")
        sum -= 1000
        if sum <= 0:
            break

5，函数的使用

①统计字符串的长度：len()

#需求：统计字符串的长度
#底层函数实现：
str = "luckydoglzh"
count = 0
for i in str:
    count += 1
print(f"字符串的长度为{count}")

#内置函数len()
print(f"字符串的长度为{len(str)}")

#自定义函数
def my_len(data):
    count = 0
    for i in data:
        count += 1
    print(f"字符串的长度为{count}")
my_len(str)

②函数的嵌套

def my_len(data):
    count = 0
    for i in data:
        count += 1
    return count
    print(f"字符串的长度为{count}")

str1 = "luckydoglzh"
str2 = "lzhhhhhh"
def sum_len(a,b):
    res = a + b
    return res

print(f"两个字符串的长度和为{sum_len(my_len(str1),my_len(str2))}")

③函数综合案例实践

"""
函数综合实例开发
"""
#定义全局变量
money = 1000000
name = None
#用户输入姓名
print("请输入你的姓名\n")
name = input()
#定义查询函数
def quary():
    global  money
    global  name
    print(f"{name}先生，你的余额还有{money}元\n")
#定义存款函数
def  sum_money():
    global  money
    global  name
    temp = input("请输入你的存款金额\n")
    temp = int(temp)
    money += temp
    print(f"{name}先生你好，你存款了{temp}元，目前卡里还有余额{money}元")
#定义取款函数
def  sub_money():
    global money
    global name
    temp = input("先生，您要取多少钱呢\n")
    temp = int(temp)
    if temp > money:
        print("先生，您的余额已不足\n")
    else:
        money -= temp
        print(f"先生，你取款了{temp}元，目前卡里还有余额{money}元")
#定义主函数
def main():
    print("查询余额请按1\t")
    print("存款请按2\t\t")
    print("取款请按3\t\t")
    print("退出请按4\t\t")
    temp = input()
    temp = int(temp)
    return temp
while(True):
    flag = main()
    if flag == 1:
        quary()
    elif flag == 2:
        sum_money()
    elif flag == 3:
        sub_money()
    else:
        break

6,数据容器

①list的使用

list可以一次性存储多种数据类型，并且还可以支持嵌套

#list 列表
#1，定义一个列表
my_list = ["lzh","isisi","amziw"]
print(my_list)
print(type(my_list))
my_list = ["lzh",2222,True]
print(my_list)
print(type(my_list))
#2，定义一个嵌套列表
ack_list = [[12,32,42],[2,55,23]]
print(ack_list)
print((type(ack_list)))

#3，通过下标索引读取对应的列表
my_list = ["lzh","dwf","gge"]
print(my_list[0][2])
print(my_list[1])
#4，修改下标元素值
my_list[0] = "21323"
print(my_list[0])
#5，在列表中进行插入元素
my_list.insert(2,"sdddd")
print(my_list)
#6，在列表中进行追加元素
my_list.append("wwww")
print((my_list))
#7，在列表中追加更多的元素
my_list.extend([4,25,23])
print(my_list)
#8，删除列表中的元素
del my_list[2]
print(my_list)
#9，pop方式删除列表中的元素
element = my_list.pop(2)
print((my_list))
print("删除的元素为：",element)
#10，指定元素的内容进行删除
my_list.remove(25)
print(f"列表为{my_list}")
#11，清除列表的内容
my_list.clear()
print(my_list)
#12，统计列表中某个元素的数量
my_list = [1,2,3,5,3,4,3,2,3,4,3,5,4,5]
count = my_list.count(3)
print(f"列表中某个元素的数量为{count}")
#13，统计列表中所有元素的数量
count = len(my_list)
print(f"列表中一共有{count}个元素")

llist练习，定义一个list，取出list中的偶数

my_list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14]
res_list = []
for element in my_list:
    if element % 2 == 0:
        res_list.append(element)
print(res_list)

②元组的使用

元组是无法修改的

#定义元组
t1 = (1,"lzhlzh",True)
print(f"t1的类型是：{type(t1)},{t1}")
t2 = tuple()
print(f"t2的类型是：{type(t2)},{t2}")
#定义单个元素的元组
t3 = ("hello")
print(f"单个元素的类型{type(t3)},{t3})")
#元组的嵌套
t4 = ((1,2,3),(4,5,6))
print(f"元组的嵌套{type(t4)},{t4}")

#下标索引取出元组中的元素
t5 = ((1,2,3),(4,5,6))
num = t5[1][2]
print(num)

#元组的操作，index查找方法
t6 = ("lzhsdd","sdsda","sdqww")
index = t6.index("sdqww")
print(index)

#元组的操作，count统计方法
t7 = (2,2,4,3,4,25,23,1,2,3)
count = t7.count(2)
print(f"2的个数为{count}")
#元组内元素的数量
num = len(t7)
print(f"元组内一共有{num}个元素")

#元组的遍历while
idx = 0
while idx < num:
    print(t7[idx])
    idx += 1
#元组的遍历for
for i in t7:
    print(i)
#修改元组的内容
t8 = (1,2,3,4,5,6,7,8,9)
#t8[0] = 9
#元组的元素不可修改！但是元组内的list元素可以修改
print(t8)
t9 = (1,2,3,["lzh","luckydog"])
t9[3][0] = "刘小浩"
print(t9)

③str的使用

#字符串的相关操作
my_str = "lucky dog lzh"
#通过下标索引值取值
value = my_str[0]
print(value)
value2 = my_str[-1]
print(value2)
#index 方法查找
value = my_str.index("dog")
print(value)
#replace 替换操作
new_str = my_str.replace("lu","小耗子")
print(new_str)
print(my_str)
#可以发现my_str并没有改变，只是创造后返回一个new_str
#字符串的分割
#切割后得到的是一个列表
my_str = "lucky dog lzh"
new_str = my_str.split( )
print(new_str)
#字符串的规整操作strip
my_str = "123221lucky dog lzh2231"
new_str = my_str.strip("123")
print(my_str)
print(new_str)
#统计某字符的出现次数 count
count = my_str.count("2")
print(count)
#统计字符串所有元素的个数 len
num = len(my_str)
print(num)
#字符串的遍历  while
idx = 0
while idx < num:
    print(my_str[idx])
    idx += 1
#字符串的遍历  for
for i in my_str:
    print(i)

字符串案例

my_list = "lucky dog lzh"
#将l替换为L
new_list = my_list.replace("l","L")
print(f"替换后的new_list为{new_list}")
#将空格替换为|
list1 = new_list.replace(" ","|")
print(f"替换后的list1为{list1}")
#基于|进行分割
list2 = list1.split("|")
print(f"分割后的list为{list2}")

④序列的操作

列表、元组、字符串都可以成为序列

切片：从一个序列里，取出一个子序列

#对list进行切片，从1开始，4结束，步长1
my_list = [0,1,2,3,4,5,6]
new_list = my_list[1:4:1]
print(new_list)
#对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0,1,2,3,4,5,6)
result2 = my_tuple[0:len(my_tuple):1]
print(result2)
#对str进行切片，从头开始到最后结束，步长1
my_str = "luckydoglzh"
result3 = my_str[0:len(my_str):1]
print(result3)
#对str进行切片，从头开始到最后结束，步长-1
my_str = "luckydoglzh"
result4 = my_str[len(my_str):0:-1]
print(result4)
#对列表进行切片，从3开始，到1结束，步长-1
my_list = [1,2,3,4,5,6,7,8]
result5 = my_list[3:1:-1]
print(result5)
#对元组进行切片，从头开始，到位结束，步长为-2
my_tuple = (1,2,3,4,5,6,7)
result6 = my_tuple[::-2]
print(result6)

⑤set集合的操作

列表可修改，支持重复元素且有序

元组、字符串不可修改，支持重复元素且有序

集合自带去重功能，顺序无法保证

列表:[]

元组：()

字符串：" "

集合:{}

#定义集合
my_set = {"无敌小狗王","luckydoglzh","luckydoglzh"}
my_set_empty = set()
print(f"my_set的类型是{type(my_set)},myset的值是{my_set}")
print(f"my_set_empty的类型是{type(my_set_empty)},my_set_empty的值为{my_set_empty}")

#添加新元素
my_set.add("lzh")
print(my_set)
#移除元素
my_set.remove("lzh")
print(my_set)
#随机取出一个新元素
element = my_set.pop()
print(element)
#清空集合
my_set.clear()
print(my_set)
#取两个集合的差集
#differece(set1,set2)  集合1有的，集合2没有的
set1 = {1,2,3,4,5}
set2 = {2,3,4,5,6}
set3 = set1.difference(set2)
print(set3)
#消除两个集合的差集
set1.difference_update(set2)
print(set1)
print(set2)
#因为集合是无序的，所以集合不支持下标索引访问
#两个集合合并为一个
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
set3 = set1.union(set2)
print(set3)
#统计集合元素的数量
set = {1,2,3,2,2,1,2,3,2}
num = len(set)
print(num)
#自动把相同元素消除了

#集合的遍历 for
for element in set:
    print(element)

⑥字典的操作

#定义字典
my_dict1 = {"刘小浩":99,"小狗王":998,"小狗王":9998}
my_dict2 = {}
print(f"字典1 的内容是{my_dict1},他的类型为{type(my_dict1)}")
print(f"字典2 的内容是{my_dict2},他的类型为{type(my_dict2)}")
#key是不允许重复的
#从字典中基于key获取value
score = my_dict1["小狗王"]
print(score)
#字典的嵌套
#字典的key和value可以是任意类型的（key不可以为字典）
stu_score_dict = {
    "刘小浩":{
        "语文":29,
        "数学":30,
        "英语":31
    },
    "小狗王":{
        "语文":88,
        "数学":74,
        "英语":50
    }
}
print(f"学生的考试信息为{stu_score_dict}")
#查看一下刘小浩的数学成绩
score = stu_score_dict["刘小浩"]["数学"]
print(score)

字典的基本操作

my_dict = {"刘小浩":99,"小狗王":100,"小耗子":1000}
#新增元素
my_dict["瑞兹王"] = 10000
print(my_dict)
#更新元素
my_dict["刘小浩"] = 292
print(my_dict)
#删除元素
score = my_dict.pop("小狗王")
print(f"删除的元素为{score},删+-"f"后字典为{my_dict}")
#清空元素
my_dict.clear()
print(my_dict)
#获取全部的key
my_dict = {"刘小浩":99,"小狗王":100,"小耗子":1000}
keys = my_dict.keys()
print(keys)
#遍历字典
#方式1
for key in keys:
    print(f"字典的key是{key}")
    print(f"字典的value是{my_dict[key]}")
#方式2
for key in my_dict:
    print(f"字典的value是{my_dict[key]}")

#统计字典内的元素数量
num = len(my_dict)
print(num)

⑥数据容器的对比总结

是否可以支持下标索引：

支持：列表，元组，字符串 ---序列类型

不支持：集合，字典   ---非序列类型

是否支持重复元素：

支持：列表，元组，字符串

不支持：集合，字典

是否可以修改

支持：列表，集合，字典

不支持：元组，字符串

⑦数据容器的通用操作

my_list = [3,2,4,1,5]
my_tuple = (3,2,4,1,5)
my_str = "absdw"
my_set = {3,2,4,1,5}
my_dict = {"key1":1,"key2":2,"key3":3,"key4":4,"key5":5}

#len元素的个数
print(f"列表 元素个数{len(my_list)}")
print(f"元组 元素个数{len(my_tuple)}")
print(f"字符串 元素个数{len(my_str)}")
print(f"集合 元素个数{len(my_set)}")
print(f"字典 元素个数{len(my_dict)}")

#max最大元素
print(f"列表  最大元素{max(my_list)}")
print(f"元组  最大元素{max(my_tuple)}")
print(f"字符串  最大元素{max(my_str)}")
print(f"集合  最大元素{max(my_set)}")
print(f"字典  最大元素{max(my_dict)}")

#min最小元素
print(f"列表  最小元素{min(my_list)}")
print(f"元组  最小元素{min(my_tuple)}")
print(f"字符串  最小元素{min(my_str)}")
print(f"集合  最小元素{min(my_set)}")
print(f"字典  最小元素{min(my_dict)}")

#容器转列表
print(f"列表转列表的结果是{list(my_list)}")
print(f"元组转列表的结果是{list(my_tuple)}")
print(f"字符串转列表的结果是{list(my_str)}")
print(f"集合转列表的结果是{list(my_set)}")
print(f"字典转列表的结果是{list(my_dict)}")

#容器转元组
print(f"列表转元组的结果是{tuple(my_list)}")
print(f"元组转元组的结果是{tuple(my_tuple)}")
print(f"字符串元组的结果是{tuple(my_str)}")
print(f"集合转元组的结果是{tuple(my_set)}")
print(f"字典转元组的结果是{tuple(my_dict)}")

#容器转字符串
print(f"列表转字符串的结果是{str(my_list)}")
print(f"元组转字符串的结果是{str(my_tuple)}")
print(f"字符串转字符串的结果是{str(my_str)}")
print(f"集合转字符串的结果是{str(my_set)}")
print(f"字典转字符串的结果是{str(my_dict)}")

#容器转集合
print(f"列表转集合的结果是{set(my_list)}")
print(f"元组转集合的结果是{set(my_tuple)}")
print(f"字符串转集合的结果是{set(my_str)}")
print(f"集合转集合的结果是{set(my_set)}")
print(f"字典转集合的结果是{set(my_dict)}")

#sorted排序功能
print(f"列表对象的排序结果{sorted(my_list)}")
print(f"元组对象的排序结果{sorted(my_tuple)}")
print(f"字符串对象的排序结果{sorted(my_str)}")
print(f"集合对象的排序结果{sorted(my_set)}")
print(f"元组对象的排序结果{sorted(my_dict)}")
#排序的结果都是列表对象
#反向排序
print(f"列表对象的排序结果{sorted(my_list,reverse=True)}")
print(f"元组对象的排序结果{sorted(my_tuple,reverse=True)}")
print(f"字符串对象的排序结果{sorted(my_str,reverse=True)}")
print(f"集合对象的排序结果{sorted(my_set,reverse=True)}")
print(f"元组对象的排序结果{sorted(my_dict,reverse=True)}")

7,函数操作

①函数作为参数传递

#函数作为参数传递
def fun_c(compute):
    result = compute(1,2)
    print(result)
    return  result

def com(a,b):
    return a*b

print(f"类型为{type(fun_c(com))},结果为{fun_c(com)}")

②lambda匿名函数

def func(compute):
    result = compute(1,2)
    return result

#lamada匿名函数
res = func(lambda a,b : a+b)
print(f"类型为{type(func(lambda a,b : a+b))},结果为{func(lambda a,b : a+b)}")

8，异常 模块 包

①了解异常

异常起始就是bug

②异常的捕获

对可能出现的异常进行提前准备，提前处理

#异常
try :
    print(f"无敌小狗王")
except Exception as e:
    print(f"异常出现啦")
else:
    print(f"根本没有异常啦")
finally:
    print(f"无论如何都要执行我噢")

③异常是具有传递性的

def func1():
    print("func1函数开始")
    a = 1/0
    print("func1函数")
def func2():
    print("func2函数启动")
    func1()
    print("func2函数")
def main():
    try:
        func2()
    except Exception as  e:
        print(f"捕获到异常啦")
    else:
        print("没有捕获到异常噢")
main()

④模块的概念

#导入python内置的time模块
import time
print("小耗子")
time.sleep(5) #通过 . 可以使用模块内部的所有功能
print("大耗子")
#只用sleep功能
from time import sleep
#导入全部功能
from time import *
#给特定功能加上别名
import  time as t
t.sleep(5)
from time import  sleep as sl
sl(4)

⑤自定义模块

新建一个.py文件，在里面定义函数即可，这里不做讲解

⑥自定义包

包的本质依然是模块

⑦安装第三方包

9，基础综合案例开发

①json是什么？

json本质上是一个带有特定格式的字符串

主要功能：负责不同编程语言中数据的传递和交互

python  ->  json  -> c语言

c语言 -> json ->python

对于python来说

import  json
#准备列表，列表每一个元素都是字典，将其转化为json
data = [{"name":"小狗王","age":"18"},{"name":"小耗子","age":"22"}]
json_str =  json.dumps(data,ensure_ascii=False)
print(f"类型为{type(json_str)},内容为{json_str}")

#准备字典，将字典转化为json
d = {"name":"周杰伦","age":"25","add":"台北"}
json_str = json.dumps(d,ensure_ascii=False)
print(f"f类型为{type(json_str)},内容为{json_str}")

#将json文件转化为python类型
data = '[{"name":"小狗王","age":"18"},{"name":"小耗子","age":"22"}]'
l = json.loads(data)
print(type(l))
print(l)

d = '{"name":"周杰伦","age":"25","add":"台北"}'
l = json.loads(d)
print(type(l))
print(l)

②数据可视化

动态GDP柱状图