python3基础大全

python基础

'''
字符串
'''
string = '上下五千年,是多少年'
# 字符串拼接
print(str(2021) + '_' + string)

# 计算字符串长度
print(len(string))

# 截取字符串
print(string[1:5:2])

# 翻转字符串
print(string[::-1])

# 分割字符串
print(string.split(','))

# 检索字符串出现的次数
print(string.count('年'))

# 子字符串在字符串首次出现的索引
# 不存在返回 -1
print(string.find('年'))

# 子字符串在字符串首次出现的索引
# 不能存在抛异常
print(string.index('年'))

# 检索字符串 是/否 以字符串开头
print(string.startswith('上'))

# 检索字符串 是/否 以字符串结尾
print(string.endswith('年'))

# 字母小转大
print('python'.upper())

# 字母大转小
print('PYTHON'.lower())

# 去除字符前后的空格
print(' 2021-08-08 中国 '.strip())

# 格式化字符串
print('%s %d %.2f' % ('一百年', 100, 3.1415926))
print('{} {} {:.2f}'.format('一百年', 100, 3.1415926))

# 字符串替换
print(string.replace('五千', '一万'))

'''
程序结构：
顺序 + 选择 + 循环
'''
# if...elif...else语句
score = 66
if score >= 90:
    print('非常优秀')
elif score >= 75:
    print('努力一下 更优秀')
elif score >= 60:
    print('踩在及格线上')
else:
    print('再不努力 搬砖都没人要你')

# 使用and连接条件语句
if 1 < 5 and 2 > 1:
    print('and需同时满足')

# 使用or连接条件语句
if 1<3 or 1<1:
    print('or只需满足其一即可')

# 使用not进行判断
if not True:
    print('真的就是假的')
if not False:
    print('假假得真')

# 重复一定的次数 - for循环
for i in string:
    print(i, end='')
print()

# for实现1-100之和
result = 0
for i in range(101):
    result += i
print(result)

# 条件循环 - while循环
count = 0
while count < 3:
    print(count)
    count += 1

# break终止循环
for b in ['san','si','wu']:
    if b == 'si':
        break
    print(b)

# continue结束本次循环
# 进入到下一次循环
for c in ['qi','ba','jiu']:
    if c == 'ba':
        continue
    print(c)

'''
字典:
键值对
{'石佛': '邓肯', '妖刀': '吉诺比利', '跑车': '帕克'}
'''
# 通过映射函数创建字典
nba = dict(zip(['石佛','妖刀','跑车'],['邓肯','吉诺比利','帕克']))

# 通过key访问value
print(nba['妖刀'])

# 遍历字典
for k,v in nba.items():
    print(k,v)

# 添加字典元素
nba['篮球之神'] = '乔丹'
print(nba)

# 修改字典元素
nba['篮球之神'] = 'jordan'
print(nba)

# 删除字典元素
del nba['篮球之神']
print(nba)

# 字典推导式
import random
print({i:random.randint(10,100) for i in range(1,5)})

'''
集合：
保存不重复元素
{'python','java','c++'}
'''
# set()函数创建
set1 = set([1,2,1,2,3])
print(set1)     # {1, 2, 3}

# 集合的添加
set1.add('python')
print(set1)

# 集合的删除
set1.remove(2)
print(set1)

# 集合的交集 &
print({1,2,3} & {2,3,4})

# 集合的并集 |
print({1,2,3} | {2,3,4})

# 集合的差集 -
print({1,2,3} - {1,2,3,4,5})

'''
函数：
通过将一段有规律、重复的代码定义为函数
从而达到一次编写 多次调用的目的
'''
# 函数的创建
def filterchar(string):
    '''
    过滤危险字符串
    :param string: 待过滤字符串
    :return:
    '''
    import re
    pat = r'(黑客)|(抓包)|(监听)'
    # return 指定返回值
    return re.sub(pat, '@_@',string)

# 调用函数
filter_result = filterchar('我是一名程序员,喜欢看黑客方面的资料')
print(filter_result)

# 空函数
def pass_func():
    pass
    ...

# 位置参数
# 调用时 参数个数和参数位置与定义一致
def wei_func(name,age,weight):
    print(name,age,weight)

wei_func('zhangsan', 18, 150)

# 关键字参数
# 只需要参数名正确即可
def guan_func(name='san', age=18):
    print(name,age)

guan_func(age=20,name='si')

# 为参数设置默认值
# 默认的形参必须在所有参数的最后
def mo_func(name,age,sex='男'):
    print(name,age,sex)

mo_func('wu',30)

# 元组可变参数 *parameter
def yuan_func(*name):
    for n in name:
        print(n)

yuan_func('张三','李四','王五')

# 字典可变参数 **parameter
def zi_func(**sing):
    for k,v in sing.items():
        print(k,v)

zi_func(**{'1':'麦迪','23':'乔丹','24':'科比'})

# 匿名函数
lamb = lambda x:x-1
print(lamb(5))

# 返回浮点数x的四舍五入结果
print(round(3.1415926, 2))

登录功能

'''
登录功能：
	正确时登录成功
	    成功后结束
	错误时给出提示
	    累计3次错误退出
	    每次错误给出剩余错误次数提示
'''

count = 1
while count <= 3:
    name = input('name:').strip()
    passwd = input('password:').strip()
    if name == 'china' and passwd == '2021':
        print('百年华诞')
        break
    else:
        print('用户名或密码错误，还有{}次登录机会'.format(3 - count))
        count += 1

实现打印 10到1

for i in range(1,11)[::-1]:
    print(i)

for i in range(10,0,-1):
    print(i)

count = 10
while count > 0:
    print(count)
    count -= 1

读取文件后修改并重新保存

'''
读取文件
修改内容后重新保存
'''
import os

with open('a1.txt', mode='r', encoding='utf-8') as f1, \
        open('a1_副本.txt', mode='w', encoding='utf-8') as f2:
    # 判断是否可读
    print(f1.readable())
    # 判断是否可写
    print(f2.writable())
    # 一行行读
    for line in f1:
        if line == '我说的是真的':
            f2.write("你们就信吧~\n")
        f2.write(line)

os.remove('a1.txt')
os.rename('a1_副本.txt', 'a1.txt')

读取文件内容并转成字典

'''
test.txt内容
    name:apple1 price:10 amount:3 year:2020
    name:apple2 price:20 amount:2 year:2021
转成：
[{'name': 'apple1', 'price': '10', 'amount': '3', 'year': '2020'}, {...}]
'''
with open('test.txt', mode='r', encoding='utf-8') as f:
    result = []
    for line in f:  # line --> 'name:apple1 price:10 amount:3 year:2020'
        dic = {}
        lst = line.split()  # lst --> ['name:apple1', 'price:10', 'amount:3', 'year:2020']
        for e in lst:  # e --> 'name:apple1'
            ll = e.split(":")  # 'name:apple1' --> [name, apple1]
            dic[ll[0]] = ll[1]  # [name, apple1] --> {'name':'apple1'}

        result.append(dic)

print(result)

取列表中奇数索引位置的数据 组成新的列表

lst = [1,2,3,4,5,6]
# 方式1
new_lst = []
for i in range(len(lst)):
    if i % 2 == 1:
        new_lst.append(i)
print("方式1：{}".format(new_lst))
# 方式2
new_lst = lst[0::2]
print("方式2：{}".format(new_lst))
# 方式3
new_lst= lambda lst:lst[0::2]
print("方式3：{}".format(new_lst(lst)))

形参定义的顺序

'''
位置参数 *args 默认值参数 **kwargs
'''
def func(l, *args, d='haha', **kwargs):
    print(l, args, d, kwargs)  # 1 (2, 3) 4 {'c': 5, 'b': 5}


func(1, 2, 3, d=4, c=5, b=5)

实参中带* 和 **

'''
实参中带 * 先打散成位置参数 再传给形参
'''


def func(*args):  # 位置形参
    print(args)  # (1, 2, 3)


lst = [1, 2, 3]
func(*lst)  # list tuple set str

'''
实参中带 ** 先将实参打散成关键字参数  然后再传递给形参
'''


def func(**kwargs):  # 关键字形参
    print(kwargs)  # {'name': 'san', 'age': 18}


dic = {'name': 'san', 'age': 18}
func(**dic)  # dict

名称空间

'''
名称空间
    内置  全局  局部
'''

a = 20  # 全局名称空间


def func1():  # 全局名称空间
    b = 20  # 局部名称空间
    print(a)

    def func2():  # 局部名称空间
        c = 30  # 局部名称空间
        print(a)

    func2()


func1()

名称空间作用域

'''
作用域
    全局作用域：内置 + 全局命名空间
    局部作用域：局部命名空间
'''
# 查看全局作用域中的内容
print(globals())  # 可以看到  func2 b c 都没有打印出来
# {'__name__': '__main__', '__doc__': '\n名称空间\n    内置  全局  局部\n',
# '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000191C275A390>,
# '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
# '__file__': 'D:/works/workspace/api/study/0623/名称空间.py',
# '__cached__': None, 'a': 20, 'func1': <function func1 at 0x00000191C2703E18>}

# 查看当前作用域中的内容
print(locals())  # 在全局 与 全局内容一致 / 在局部 与 局部内容一致


def func3():
    a = 111
    def func4():
        pass
    print(locals())     
    # {'func4': <function func3.<locals>.func4 at 0x0000029E43273840>, 'a': 111}


func3()

函数嵌套

def outter():
    print("outter开始执行")

    def inner1():
        print('inner1 开始执行')

        def inner1_1():
            print("inner1_1开始执行")

        inner1_1()
        print('inner1 执行完毕')

    def inner2():
        print('inner2开始执行')

    inner2()
    inner1()


outter()
'''
运行结果：
    outter开始执行
    inner2开始执行
    inner1 开始执行
    inner1_1开始执行
    inner1 执行完毕
'''

global关键字

'''
在局部名称空间中 global 变量a 表示可以直接修改全局变量 a
如果global 变量a 在全局中不存在时 自动在全局创建一个 变量a
'''
a = 10


def func():
    global a
    a = 30


func()
print(a)  # 30

nonlocal 关键字

'''
在局部空间范围内（非全局）
从自身函数的作用范围内 一层层的往外层函数范围查找
找到则引用 并可以修改原内容
找不到则报no binding for nonlocal '变量名' found异常
'''


def outter():
    a = 10

    def inner():
        nonlocal a
        a = 20

    inner()
    print(a)  # 20


outter()

max() 和min()

def func(*args):
    '''
    传入n个数返回最大最小
    格式如下：{'max':10,'min':2}
    '''
    return {'max': max(args), 'min': min(args)}


print(func(1, 2, 6, 7, 8))  # {'max': 8, 'min': 1}

传入一个参数n 返回n得阶乘

def cal(n):
    '''
    传入一个参数n 返回n得阶乘
    例如：cal(4)  计算  4*3*2*1
    '''
    sum = 1
    while n >= 1:
        sum *= n
        n -= 1
    return sum


print(cal(4))   # 24

初始化扑克牌

def puke():
    '''
    初始化扑克牌
    '''
    result = []
    huase = ['红桃', '黑桃', '梅花', '方块']
    dianshu = [2, 3, 4, 5, 6, 7, 8, 9, 10, 'J', 'Q', 'K', 'A']
    for hua in huase:
        for dian in dianshu:
            result.append((hua, dian))

    return result


print(puke())

形参中默认值为可变类型

def lst_add(a, lst=[]):
    '''
    形参中得默认值为 可变得数据类型
    每次使用得都是同一个（累加逻辑）
    '''

    print(id(lst))
    lst.append(a)
    return lst


ls1 = lst_add(10)
print(ls1)  # [10]
ls2 = lst_add(123, [])
print(ls2)  # [123]
ls3 = lst_add('abc')
print(ls3)  # [10, 'abc']

99乘法表

def jiujiu():
    '''
    99乘法表
    1*1=1
    ...
    9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
    '''
    for i in range(1, 10):
        for j in range(1, i + 1):
            print('{}*{}={}'.format(i, j, i * j), end=' ')
        print()  # 打印空 等于 print('', end='\n')


jiujiu()

闭包

def outter():
    '''
    闭包：在内层函数中访问外层函数得变量
    闭包得作用：
        可以保护变量不受侵害
        可以让一个变量常驻内存中
    :return:
    '''
    a = '闭包'

    def inner():
        print(a)

    print(inner.__closure__)  # 查看是否为闭包
    return inner


b = outter()
b()  # 闭包
b()  # 闭包

迭代器

'''
可迭代对象：
    所有带 __iter__ 方法得对象， 可以被for循环    
迭代器：
    可迭代对象可以使用 __iter__()方法来得到一个迭代器
    迭代器包含__iter__() 和 __next__()方法
    迭代器可以不依赖索引的方式取值
    通过__next__()方法一次只往下拿一个元素，几乎不占用内存
    一直取到直到报StopIteration为止
'''
s = '中国'
print('__iter__' in dir(s)) # True --> 表示为可迭代对象
st = s.__iter__()   # 得到一个迭代器
print(st.__next__())    # 中
print(st.__next__())    # 国
# print(st.__next__())    # StopIteration 异常

通过迭代器模拟for循环

def my_for(lst):
    '''
    通过迭代器模拟for循环
    :return:
    '''
    lt = lst.__iter__() # 转成迭代器
    while 1:
        try:
            print(lt.__next__())    # 取下一个值
        except StopIteration:
            break   # 异常则退出循环

my_for([1,2,3,4])
'''
结果：
    1
    2
    3
    4
'''

判断可迭代对象 / 迭代器

from collections import Iterable  # 可迭代对象
from collections import Iterator  # 迭代器

lst = [1, 2, 3, 4, 5]
print(isinstance(lst, Iterable))  # True
print(isinstance(lst, Iterator))  # False

lt = lst.__iter__()
print(isinstance(lt, Iterable))  # True
print(isinstance(lt, Iterator))  # True

枚举

lst = ['北京', '上海', '广州', '曹县']
for index, element in enumerate(lst):
    print(index, element)

# 等同于
for i in range(len(lst)):
    print(i, lst[i])

生成器

'''
生成器
    生成器的本质是迭代器
    方法中包含 yield 关键字 
'''


# 普通方法 一次返回10万条， 再一条一条的取
def func1():
    lst = []
    for i in range(100000):
        lst.append('衣服' + str(i))
    return lst


yi = func1()  # 占用内存大
print(yi[0])  # --> 衣服0


# 生成器方式， 每次返回一条
def func2():
    for i in range(100000000):
        yield '衣服' + str(i)


y = func2()  # 此时 不会执行函数  且占用内存小
print(y.__next__())  # 执行函数（到 第一个yield） --> 衣服0
print(y.__next__())  # 执行函数（到 下一个yield） --> 衣服1
print(y.__next__())  # 执行函数（到 再一个yield） --> 衣服2

send()

'''
send 可以往yield后传值
    在第一次执行生成器代码时 不能使用send()
    不可以给最后一个yield传值
'''


def eat():
    print('我吃什么？')
    a = yield '馒头'
    print(a)
    b = yield '香蕉'
    print(b)
    yield 789


gen = eat()  # 生成器
res1 = gen.__next__()  # 走到第一个yield '馒头'（不包含a=）
print(res1)  # 馒头
# 将水饺往第一个yield后传值 并赋值给a 然后打印a 并走到第二个yield '香蕉'
res2 = gen.send('水饺')
print(res2)  # 香蕉
# 将哈密瓜往第二个yield后传值 并赋值给b 然后打印b 并走到最后一个yield 789
res3 = gen.send('哈密瓜')
print(res3)  # 789

列表推导式

'''
列表推导式
    语法：[value for循环 条件筛选]
'''
# 普通方式
lst = []
for i in range(5,10):
    lst.append('神州{}号'.format(i))
print(lst)  # ['神州5号', '神州6号', '神州7号', '神州8号', '神州9号']

# 列表推导式
lst = ['神州{}号'.format(i) for i in range(5,10)]
print(lst)  # ['神州5号', '神州6号', '神州7号', '神州8号', '神州9号']

# 练习：10以内 除以3的数的平方
lst = ['{}的平方 {}'.format(i, i*i) \
		for i in range(10) if i%3==0 and i > 0]
print(lst)  # ['3的平方 9', '6的平方 36', '9的平方 81']

# 练习升级：两层列表统计 张姓名字
# 普通方式
names = [['张三','李四','张二蛋'],
         ['王五','老六','张飞']]
lst = []
for line in names:
    for name in line:
        if name.startswith('张'):
            lst.append(name)
print(lst)  # ['张三', '张二蛋', '张飞']

# 列表推导式
lst = [name for line in names \
		for name in line if name.startswith('张')]
print(lst)  # ['张三', '张二蛋', '张飞']

字典推导式

'''
字典推导式
    语法：{key:value for循环 条件筛选 }
'''
# [11,22,33]  --> {0：11, 1:22, 2:33}
lst = [11, 22, 33]
dic = {k: v for k, v in enumerate(lst)}
print(dic)  # {0: 11, 1: 22, 2: 33}

lambda

'''
lambda匿名函数
'''
# 普通方法实现
def func(n):
    return n * n


a = func(5)
print(a)  # 25
print(func.__name__)  # func

# 匿名方法实现
b = lambda n: n * n
print(b(6))  # 36
print(b.__name__)  # <lambda>

# lambda 处理字典实例
dic = {'希望': '0.0036', '市民': '0.0026', '居民': '0.0040'}
# 按照字典的value 默认升序排
dic1 = sorted(dic.items(), key=lambda item: item[1])
print(dic1)  # [('市民', '0.0026'), ('希望', '0.0036'), ('居民', '0.0040')]
# 按照字典的value 降序排
dic2 = sorted(dic.items(), key=lambda item: item[1], reverse=True)
print(dic2)  # [('居民', '0.0040'), ('希望', '0.0036'), ('市民', '0.0026')]

# 将字典内容格式化输出
for v in dic2:
    print('{}:{:.2f}'.format(v[0], float(v[1]) * 100), end=' ')

'''
运行结果：
	居民:0.40 希望:0.36 市民:0.26 
'''

sorted()

'''
sorted() 排序
    iterable：可迭代的
    key：把可迭代对象中的每个元素拿出来 交给key
    reverse：正序 / 倒序 
'''
lst = ['张三', '张利斯', '王张利斯', '六王张利斯', '周年']


def func(n):
    return len(n)


ls = sorted(lst, key=func)
print(ls)  # ['张三', '周年', '张利斯', '王张利斯', '六王张利斯']

ls = sorted(lst, key=func, reverse=True)
print(ls)  # ['六王张利斯', '王张利斯', '张利斯', '张三', '周年']

filter()

'''
filter() 过滤
    function: 方法名
    iterable: 可迭代的
'''
ls = ['张无忌', '张三丰', '乔峰', '郭靖', '狗蛋']


def func(name):
    # if name[0] == '张':
    if name.startswith('张'):
        return False
    else:
        return True


# 将ls中的每一项传递给func，然后将True的保留，Flase的过滤掉
# f = filter(func, ls)
f = filter(lambda name: not name.startswith('张'), ls)

print('__iter__' in dir(f))  # True  可迭代
for name in f:
    print('filter过滤后的符合的姓名为:{}'.format(name))

map()

'''
map() 映射
'''
ls = [1, 2, 3, 7, 8, 9]
def func(num):
    return num * num

# 把后面可迭代对象中的每个元素拿出来交给func, 返回的是func的执行结果
# m = map(func, ls)
m = map(lambda num: num ** 2, ls)
print('__iter__' in dir(m))
print(list(m))  # [1, 4, 9, 49, 64, 81]

# 实际使用情况（分而治之）
map(func, map(func, map(func, ls)))

re

import re

str = "192.0.0.1?!289.0.0.1!0.0.0.0!192.163.10.28?192.0.0.1"

# 切割成ip列表
ip_list = re.split('\?!|!|\?', str) # ?在re中为非贪婪模式，需转义
# 按ip最后一位排序
ip_list = sorted(ip_list, key=lambda v: v[-1])
# 打印结果
print(ip_list)

继续复习补充中，参考B站
python全栈开发 (完整共145天)【学完可以就业】
https://www.bilibili.com/video/BV1PA411x72W?p=46&spm_id_from=pageDriver