应知道的16个Python基础知识

列表推导式

# 列表推导式，用一行代码生成一个有规律的列表
# 列表推导式，用一行代码生成一个有规律的列表
import random

list_comprehension =[i for i in range(10)]
print(list_comprehension)

list_comprehension2 =[(x,y)for x in range(4) for y in range(5,10)]
print(list_comprehension2)

list_comprehension3 =[x for x in range(1,10,2)]
print(list_comprehension3)

# 随机产生一个列表
list_comprehension4 =[random.randint(1, 10) for x in range(1,10,2)]
print(list_comprehension4)

文件操作

文件操作（CSV、excel，xml）

列表作为形参

def add_num(num,temp=[]):
    temp.append(num)
    print(temp)
#1、如果一个函数的形参他有默认值，我们称之为缺省参数
# 2、如果这个缺省参数的默认值是一个列表，那么不管调用多少次这个函数，每次都是用的一个列表
# 3、如果某次调用这个函数时，向这个列表中添加、修改、删除了数据，南无当下次调用这个函数的时候，你会发现这个列表中的数据改变了
# 总结：如果函数的形参是个列表，那么每次调用函数时，都用同一个列表
add_num(11)
add_num(22)
add_num(33)
add_num(44)


def add_dictory(name,value,dictory={}):
    dictory[name]=value
    print(dictory)

add_dictory("addr","china")
add_dictory("tel","010112200")

列表中嵌套字典并排序

nums = [1, 23, 3, 35, 76, 12, 32, 19, 89]

# sort可以对原列表直接拍讯，不需要返回值
# print(nums.sort())  # 输出为空，排序后没有返回值
nums.sort()
print(nums)  # 输出为排序后的列表

# 列表中嵌套字典

infos = [
    {"name": "darly", "age": 30},
    {"name": "flex", "age": 10},
    {"name": "juanHong", "age": 25}
]


# 嵌套字典的列表无法直接拍讯
# infos.sort()  # 此时报错

def get_value(temp):
    return temp["age"]
infos.sort(key=get_value)
print(infos)
def get_value_name(temp):
    return temp["name"]
infos.sort(key=get_value_name)
print(infos)

infos.sort(key=lambda temp:temp["name"])
print(infos)

os walk遍历文件夹

深度遍历：os walk是深度遍历，找到一个文件夹后，将文件夹中所有的文件遍历完成够，再遍历其它文件夹

广度遍历：先遍历当前层的文件夹的文件，遍历完一层后，再遍历下一层

# os模块中walk
# walk能够遍历出文件夹中所有文件和文件夹
import os
files = os.walk("./")  # 返回值是一个迭代器
for temp in files:
    print(temp)

递归遍历文件夹

# 目的：使用递归函数遍历文件夹

import os


def list_file_folder(path_name):
    file_foledr_name = os.listdir(path_name)
    print(file_foledr_name)
    for name in file_foledr_name:
        temp_path_name = path_name + "/" + name
        if os.path.isdir(temp_path_name):
            print("%s是文件夹" % name)
            list_file_folder(temp_path_name)
        else:
            print("%s不是文件夹" % name)


list_file_folder("./")

实例方法、类方法、静态方法

python面向对象编程（类的定义，类的实例化，类的封装）

类属性及类方法、实例方法

class Tool(object):
    tools_num = 0  # 定义一个类属性，用来存储共享的数据

    def __init__(self, name):
        self.name = name
        print(f"创建了工具{name}")
        Tool.tools_num += 1  # 类属性，不因实例对象改变而改变

    # 实例方法，利用实例方法获取类属性不合理，因此可以修改为静态方法
    # 类属性不因实例对象而改变，类属性可以通过下面方法获取，但是不合理，类属性不属于对象
    def print_info(self):
        print("工具的总数为：", Tool.tools_num)

    # 类方法，使用类方法获取类属性
    @classmethod
    def print_info2(cls):
        print("工具的总数为：", cls.tools_num)


tieqiao = Tool("铁锹")
chutou = Tool("锄头")
dianciluo = Tool("电磁炉")

tieqiao.print_info()   # 使用实例方法获取类
Tool.print_info2()     # 使用类方法获取类属性
print(Tool.tools_num)  # 使用类直接获取类属性
tieqiao.print_info2()  # 对象可以调取类方法（类不可以直接调用实例方法）

静态方法

import time


class TimeTest(object):
    def __init__(self, hour, minute, second):
        self.hour = hour
        self.minute = minute
        self.second = second

    # 这个方法只是显示当前时间，与类相关属性及方法没有太大关系，此时可以将此方法修改为静态方法
    def show_time(self):
        # print("当前时间{0}".format(time.strftime('%H:%M:%S',time.localtime())))
        # print(f"当前时间{time.strftime('%H:%M:%S',time.localtime())}")
        # print("当前时间%s" % time.strftime('%H:%M:%S',time.localtime()))
        print("当前时间%s" % time.strftime('%H:%M:%S'))

    # 静态方法
    @staticmethod
    def show_time2():
        print("当前时间%s" % time.strftime('%H:%M:%S'))


t = TimeTest(22, 30, 32)
t.show_time()
# 可直接调用静态方法
TimeTest.show_time2()

三元运算符（三目运算符）

格式 条件成立返回的数据 if 条件 else 条件不成立返回的数据

对比lambda ：lambda 形参1，形参2，形参3：表达式
对比列表推导式：[ x for x in y if 条件]

# 三元运算符（三目运算符）

# 格式 条件成立返回的数据 if 条件 else 条件不成立返回的数据

a = True if 2>1 else False
print(a)

def get_big_num(a,b):
    """获取两个数中最大的数"""
    if a>b:
        return a
    else:
        return b

def get_big_num2(a,b):
    return a if a>b else b

print(get_big_num(20,80))
print(get_big_num2(90,80))

负索引

字符串、列表、元组等都可以用负索引获取元素

inf = "abcdef"
print(inf[-1])
nums = [11,12,23,45,43]

print(nums[-1])
print(nums[1:-3])

join和spilit

str = "lift is short"

words = str.split(" ")
print(words)
words = words[::-1]   # 从后向前取值，全部去完，结果就是一个倒序
str=" ".join(words)    # 参数是一个列表


print(str)

打乱列表的顺序

import random

nums = [11,22,33,44,55,66]
m = random.choice(nums)   # 在容器中人选一个元素
print(m)
n = random.choices(nums, k=3)  # 在元素中任选k个数组成新元素（有可能重复）
print(n)
random.shuffle(nums)   # 对可变类型参数进行洗牌, shuffle洗牌
print(nums)

简单的加密功能

import random
password_sentence = "This is my password。 Please Keep secret"
password_list = password_sentence.split(" ")
# print(password_list)
random.shuffle(password_list)
# print(password_list)
result_password="".join(password_sentence)
print(result_password)

字典推导式

# 列表推导式
nums = [i*2 for i in range(3)]

# 字典推导式  任何不可遍历的数据都可以当做key 例如：字符串，数字
dict_num = {i:i*2 for i in range(3)}
print(dict_num[0])

# 快速更换key和value——原key做值，原value做键
dict1= {"a":10, "b":34}
dict2 = {v:k for k,v in dict1.items()}
print(dict2)

# 大写key与小写key转换
dict1= {"a":10, "b":34}
dict2 = {k.upper():v for k,v in dict1.items()}
print(dict2)

format格式化

# 通过位置
print("="*10+"通过位置"+"="*10)
print("{0}，{1}".format("laowang",20))
print("{0}今年{1}了".format("老王",20))
print("{},{}".format("laowang",20))
print("{1},{0}".format("laowang",20))

# 通过位置
"""========================通过位置================================"""
print("="*10+"通过位置"+"="*10)
print("{0}，{1}".format("laowang",20))
print("{0}今年{1}了".format("老王",20))
print("{},{}".format("laowang",20))
print("{1},{0}".format("laowang",20))
"""=======================通过关键字=================================="""
print("="*10+"通过关键字"+"="*10)
print("{name}，{age}".format(name="laowang",age = 20))
# 方式2
class Format_str():
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __str__(self):
        # self就是实例对象，将实例对象返回到字符串中，通过实例对象的属性就可以获取属性值
        # return "name is {self.name},is {self.age} old".format(self=self)
        return "name is {a.name},is {a.age} old".format(a=self)
print(Format_str("laowang",age=100))



"""==============通过列表映射======================="""
print("="*10+"通过映射list"+"="*10)
a_list = ["laowang",20,"china"]
# {0[0]} 第一个0就是format第一个参数，因为format第一个参数是列表所以0[x]代表获取列表第几个元素
print("my name is {0[0]}，from {0[1]},age is {0[2]}".format(a_list))


"""===========通过字典映射==============="""
print("="*10+"通过映射dict"+"="*10)

a_dict = {"name":"laowang","age":20, "province":"shanghai"}
print("my name is {name}，from {province},age is {age}".format(**a_dict))
print("my name is {info[name]}，from {info[province]},age is {info[age]}".format(info = a_dict))  # 字符串中字典取值过程键不需要加引号
# print("my name is {info[name]}，from {info['province']},age is {info['age']}".format(info = a_dict))  #这种方式是错误的
# print("my name is {a_dict['name']}，from {a_dict['province'},age is {a_dict['age'}".format(a_dict))  #这种方式是错误的

"""==================填充与对其========================"""
print("="*10+"填充对其"+"="*10)
print("****{:>8}****".format("189"))    # >靠右对其
print("****{:<8}****".format("189"))    # < 靠左对齐
print("****{:+<8}****".format("189"))    # < 靠左对齐
print("****{:0>8}****".format("189"))   # 左侧填充0+字符串共占8个字符
print("****{:a>8}****".format("189"))   # 左侧填充a+字符串共占8个字符

"""======================保留精度============================"""
print("========保留精度===========")
print("{:.2f}".format(123456789526577))   #浮点数据保留两位小数
print("{:.2f}".format(12345678.9526577))

"""=================用来做金额的千位分割符================="""
print("=======用来做金额的千位分割符=====")
print("{:,}".format(12545457845454))

"""=================其它类型——进制================="""
# 主要就是进制，b,d,o,x分贝是二进制，十进制，八进制，十六进制
print("==========进制=============")
print("{:b}".format(18))
print("{:d}".format(18))
print("{:o}".format(18))
print("{:x}".format(18))