01_Python 基础

Python解释器 & pycharm安装

注释 #

变量

常量

input
#输入框

if
#条件判断

while
#循环

关键字 continue break 
关键字 pass

01. for循环

for 变量 in 可迭代的东西:
    代码

把可迭代的东西中的每一项内容拿出来，挨个的赋值给变量，每一次赋值都要执行一次循环体（代码）

for循环想要计数，需要借助range
range(n):从0数到n，不包含n
range(m,n):从m数到n，不包含n
range(m,n,s):从m数到n，不包含n，每次的间隔步长是s

02. 数据类型

type()
#查看数据类型

float 
int 
bool

03. 字符串

3.1 字符串格式化

1. 字符串格式化问题
# %s 字符串占位符
# %d 整数占位符
# %f 小数占位符
s = "%s,%d,%f" % {num1,num2,num3}
s2 = "{},{}".format(num1,num2)
s3 = f"{},{}" #f-string

3.2 字符串切片

s = "hello world"

s[3]
s[-1]

s[start,end]
s[0:5]
s[:5]
s[6:]
s[-3:-1]

s[start:end:step]
s[::-1] # 可以给切片添加步长来控制切片的方向，-1表示倒序
s[-1:-10:-3]

3.3 字符串常规操作

字符串的操作一般不会对原字符串产生影响，一般是返回一个新的字符串

# 1. 字符串首字母大写
s = "hello world"
ss = s.capitalize()

# 2. 每个单词的首字母大写
ss = s.title()

# 3. 全部变成小写字母
ss = s.lower()

# 4. 全部变成大写字母
ss = s.upper()
print(ss)

# 5. 忽略大小写验证码
verify_code = "aD1v"
user_code = input(f"请输入验证码（{verify_code}:）")
print(user_code)

if verify_code.upper() == user_code.upper() :
    print(verify_code.upper(),user_code.upper())
    print("true,go go go")
else:
    print("test")

3.4 字符串切割和替换

# 切割和替换

# strip()   去掉字符串两边的空白符（空格、\t、\n）
s = "   hello  world    "
s1 = s.strip()
print(s1)

# 案例
username = "admin"
password = "psd"
user = input("username:").strip()
psd = input("password:").strip()
if user == username and psd == password:
    print("登陆成功")
else:
    print("登录失败")

# replace(old,new)  字符串替换

s = "hi man"
ss = s.replace("man","boy")
print(ss)

# split 字符串切割，用谁切就会损失掉睡
s = "java_aaa_home_world"
ss = s.split("_")   #切割后的结果放到列表中
print(ss)

3.5 查找和判断

# 查找和判断

# find()    返回值是找到元素的下标，-1代表未找到
s = "hello world"
print(s.find("llo"))
print(s.find("wod"))

# index()   返回元素下标，如果报错表示未找到
# print(s.index("hell"))
# print(s.index("aa"))

# in   判断是存在，返回true 或 false
# not in    判断是否不存在
print("hello" in s)
print("hh" not in s)

# startswith("str")  判断字符串是否以str开头
# endswith("str")    判断字符串是否以str结尾
if s.startswith("hello"):
    print("true")
else:
    print("false")

# isdigit() 判断是否是整数
money = input("请输入您的余额")
if money.isdigit():
    # money = int(money())
    print(type(money))

04. 列表

s = "hello world"
# len()		长度  
# join()	

# 列表
# []来表示一个列表，中间元素用 , 分隔开

a = [123,"test","hello world",["hh,hh","jj"]]
print(a[3][1])

# 特性：
#       1. 可以像字符串一样也有索引和切片
#       2. 索引超过范围会报错
#       3. 可以用for in 遍历


# 列表的增删改查
lst = []

# 增
# append()  追加
lst.append("中华田园犬")
lst.append("二哈")
# insert()  插入
lst.insert(1,"柴犬")
# extend()  合并两个列表，批量的添加
lst.extend(["萨摩耶","泰迪"])
print(lst)

# 删
# pop() 给出被删除的索引，返回被删除的元素
ret = lst.pop(2)
print(lst)
print(ret)
# remove()  给出删除的元素，无返回值
lst.remove("泰迪")
print(lst)

# 改 直接用索引更改
lst[2] = "秋田犬"
print(lst)

# 查 直接用索引进行查询操作
print(lst[0])


# 练习
# 把所有姓张的改成姓王的

lst2 = ["张无忌","张三丰","弘一法师"]
for i in lst2:
    if i.startswith("张"):
        new_name = "王" + i[1:]
        lst2[lst2.index(i)] = new_name

print(lst2)

# ——————————————————————————————————————————————————————————

# 列表的其他操作

# sort()    升序, reverse=True 倒序

lst = [1,5,2,4,6]
lst.sort()
print(lst)
lst.sort(reverse=True)
print(lst)

# 列表的循环删除
lst = ["张三丰","张无忌","灭绝"]
temp = []
for item in lst:
    if item.startswith("张"):
        temp.append(item)
print(lst)
for item in temp:
    lst.remove(item)
print(lst)
print(temp)

05. 元组

# tuple 元组，特点：不可变的列表
t = (1, 2, 3, 4, 5)

print(t)
print(t[2])

# * 元组如果只有一个元素，需要在元素的末尾添加一个逗号

06. 集合

# set集合，set集合是无序的

# 不可哈希：python中的set集合进行数据存储的时候，需要对数据进行哈希计算，根据计算出来的哈希值进行存储数据
#         set集合要求存储的数据必须是可进行哈希计算的。
#         可变的数据类型：list，dict，set
# 可哈希：不可变的数据类型，int，str，tuple，bool

s = {1, 2, 3}

# * 作用：可以去重复

lst = [1,2,3,4,5,2,4,5,6,2,4,5,5,5,5]
print(lst)
print(lst(set(lst)))

07. 字典

# 字典是以键值对的形式进行存储数据的
# 字典的表示方式：{key:value,key2:value,key3:value}

dic = {"jay": "周杰伦", "金毛狮王": "谢逊"}
val = dic["jay"]
print(val)

# 字典的key必须是可哈希的数据类型
# 字典的value可以放任何数值

# 字典的增删改查
# 增
dic = dict()
dic['jay'] = "周杰伦"
dic["tom"] = "jerry"
print(dic)

# 删
dic.pop("jay")
print(dic)

# 查
print(dic["tom"])      # 如果key不存在，程序报错
print(dic.get("tom"))   # 如果key不存在，程序返回none

dic = {
    "伍六七": "玄武国第一刺客",
    "大飞": "小飞的爸爸",
    "小飞": "大飞的儿子",
    "鸡大保": "大飞鸡友"
}

# 1. 使用for循环遍历字典
for key in dic:
    print(key, dic[key])

# 2. 把所有的key全部保存到一个列表中
# keys()
print(list(dic.keys()))

# 3. values()   拿到所有的value

# 4. items()    直接拿到字典中的key和value

a, b = (1, 2)   # 元组或者列表都可以执行该操作，该操作被称为结构结构（解包）
print(a)
print(b)

# 字典的遍历
dic = {
    "伍六七": "玄武国第一刺客",
    "大飞": "小飞的爸爸",
    "小飞": "大飞的儿子",
    "鸡大保": "大飞鸡友"
}
temp = []
for key in dic:
    if key.startswith("大"):
        temp.append(key)

for t in temp:
    dic.pop(t)

print(dic,temp)

08. 字符集和编码

"""
    1. 字符集和编码
    0 1  =>  101010100  =>  二进制转化成十进制  <==>
    ascii => 编排了128个文件符号，只需要7个0和1就可以表示了

    2. bytes
        str.encode("编码")    进行编码
        bytes.decode("解码")  进行解码

"""

# encode()
s = "周杰伦"
bs1 = s.encode("gbk")   # b'xxxx' bytes类型
bs2 = s.encode("utf-8")
print(bs1)
print(bs2)

# decode()
bs = b'\xd6\xdc\xbd\xdc\xc2\xd7'
s = bs.decode("gbk")    # 解码
print(s)

09. 运算符

"""
1. 算术运算
    + - * / % //
2. 比较运算
    > < >= <= == !=
3. 赋值运算
    =   +=  -=  *= ...
4. 逻辑运算
    and or  not
    括号 > 算not > and > or
5. 成员运算
    in
    not in
"""

10. 文件操作

"""
文件操作
1. open(文件路径, mode="", encoding="")
    文件路径： 绝对 相对
    mode:    
    	r : read 读取
    	w : write 写
    	a : append 追加写入
    	rb : 查看图片
    	wb : 写图片
    width：上下文，不需要手动关闭一个文件	
    
    修改文件：
    	1. 从源文件中读取内容
    	2. 从内存中进行调整（修改）
    	3. 把修改后的内容写入新文件中
    	4. 删除源文件，将新文件重命名成源文件
    
    .read()  全部读取
    .readline() 读取一行  
    .readlines() 以列表的形式打印出来

	

"""

f = open("test.txt", mode="r", encoding="utf-8")
for line in f:
    print(line.strip())
    
# 自动关闭文件     
with open("test.txt", mode="r", encoding="utf-8") as f:
	for i in f:
		print(i.strip())  
    

# 姓周的改成姓张的
import os
import time

with open("test.txt", mode="r", encoding="utf-8") as f,open("test2.txt", mode="w", encoding="utf-8") as f2:
    for line in f:
        line.strip()
        if line.startswith("周"):
            line = line.replace("周", "张")
        f2.write(line)

time.sleep(3)
os.remove("test.txt")
time.sleep(3)
os.rename("test2.txt","test.txt")

11. 函数

# 函数声明
def 函数名():
    函数体
    
# 调用
函数名()

"""
参数：可以在函数调用的时候，给函数传递一些信息

分类：
	1. 形参，在函数定义的时候，需要准备一些变量来接收消息
		1. 位置参数，按照位置一个一个的去声明变量
		2. 默认值参数，在函数声明的时候给变量一个默认值，如果实参不传递信息，此时默认值生效，否者就不生效
		3. 动态传参
			1. *args，表示接收所有的位置参数的动态传参，接收到的所有参数被处理成元组
			2. **kwargs, 表示接收关键字的动态传参，接收到的所有参数会被处理成字典
		顺序：位置 > *args > 默认值 > **kwargs 
			
			
	2. 实参，实际在调用的时候传递的信息
		1. 位置传参，按照位置顺序进行传递参数
		2. 关键字传参，按照参数的名字进行传递参数
			function(name1 = "test2",name2 = "test1")
		3. 混合传参，位置参数放前，关键字参数放后面
			function("test1","test2",name3="test3")
		实参在执行的时候，必须要保持形参有数据
 	
 	*在实参位置，是把列表打散成位置参数进行传参
 	**在实参位置，可以吧字典自动转化成关键字参数进行传递
"""


"""
    返回值：函数执行之后，会给调用方一个结果，这个结果就是返回值
    关于return：
    	函数只要执行到了return，函数就会立即停止并返回内容，函数内的return的后续的代码不会执行
    	1. 如果函数内没有return，此时外界收到的是None
    	2. 如果写了return
    		1. 只写了return，后面不跟数据，接收值是None
    		2. return 值，此时表示函数有一个返回值，外界能够收到一个数据
"""

12. 内置函数

13. 作用域

作用域：变量的访问权限

全局变量 	全局作用域
局部变量	局部作用域

14. 函数的嵌套

函数可以嵌套函数

综上：
	1. 函数可以作为返回值进行返回
    2. 函数可以作为参数进行互相传递
函数实际上就是一个变量名，都是表示一个内存地址

15. global 和 nonlocal

 """
global : 在局部引入全局变量

nonlocal : 向外找一层 ，看看有没有该变量，如果有就引入，如果没有 继续向外一层，不包括全局变量

"""

a = 10
def func():
    # 把外面的全局变量引入到局部
    global a
    a = 20
func()
print(a)

def func1():
    a = 10
    def func2():
        nonlocal a
        a = 20
    func2()
    print(a)
func1()

16. 闭包

"""
闭包：本质，内层函数对外层函数的局部变量的使用，此时内层函数被称为闭包函数
	1. 可以让一个变量常驻于内存
	2. 可以避免全局变量被修改
"""

def func():
    a = 10
    def inner():
        nonlocal a
        a += 1
        return a
    return inner

ret = func()
a = 20
r1 = ret()
print(r1)
r2 = ret()
print(r2)

17. 装饰器

"""
内容回顾：
	1. 函数可以作为参数进行传递
	2. 函数可以作为返回值进行返回
	3. 函数名称可以变成变量一样进行复制操作
	
装饰器：
	 装饰器本质上是一个闭包
	 作用：
	 	在不改名原有函数调用的情况下，给函数增加新的功能
	 	直白：可以在函数前后添加新功能，但是不改变源代码
	 	
	 在用户登录的地方，日志
	 雏形：
	 	def 
"""

def guanjia(game):
    def inner():
        print("start")
        game()
        print("end")
    return inner

def play():
    print("play game")

@guanjia
def playFootball():
    print("play football")

play = guanjia(play)

play()
playFootball()