Python基础

print("hello world!!")  # 单行注释
'''
    多行注释
    ctrl+/ 注释/取消注释
    ctrl+ enter 在下方插入一个空行
    
'''
print("hello world!!")
# -----------------------------------------------------------
# 变量： 内存地址的别名，用来存储数据
# 定义： 变量名 = 数据值    变量名要遵循标识符 定义规则
name = "messi"
age = 36
print(name, "'s age is", age)
# -----------------------------------------------------------
#    数据类型：数字（int,float,long,complex)、布尔、字符串、列表、元组、字典
# 可以用type()查看数据类型
result = 10
print(type(result))
result = "hello"
print(type(result))
result = True
print(type(result))
# -----------------------------------------------------------
# keyword
import keyword

print(keyword.kwlist)
# -----------------------------------------------------------
# 格式化输出，格式化占位符，%s 字符串， %d int ， %f 浮点型float
print("我的名字是%s,我的年龄是%d" % (name, age))
print(f"我的名字是{name},我的年龄是{age}")  # f-string
# -----------------------------------------------------------
# 输入： input()函数   input(给用户的提示信息)  得到的数据都是字符串类型.
name = input("what is your name?")
# -----------------------------------------------------------
# 类型转换： 转换后类型名（需转换的变量） 如：float(age) 不改变原始数据，生成新的数据
# eval() 还原原来的数据类型   变量如果没有定义，则不能使用
a1 = float(age)
# -----------------------------------------------------------
# + - * / //（取整除） % **（指数）
# 逻辑运算符  and  or not    短路性
# --------------------------------------------------------------------------------------------------------------------
if age > 18:
    print("i'm not a teenager")
# import random  randint(a,b)  返回a-b之间的一个整数
'''
    - 三目运算符：变量 = 表达式1 if 判断条件 else 表达式2 
    - for循环：
        for 变量 in 字符串：
            代码
        for 循环也称为for遍历
'''
num = 2 if age < 10 else 1
print(num)
# -----------------------------
# 打印正方形-while
i, j = 0, 0
while i < 5:
    j = 0
    while j < 5:
        print("*", end=" ")
        j += 1
    print()
    i += 1
# 打印正方形-for
for i in range(0, 5):
    for j in range(0, 5):
        print("*", end=" ")
    print()
# -----------------------------
# 打印三角形 - while
i = 1
while i < 6:
    j = 0
    while j < i:
        print("*", end=" ")
        j += 1
    print()
    i += 1
# 打印三角形 -  for
for i in range(5):
    for j in range(i + 1):
        print("*", end=" ")
    print()
'''
    只能用在循环中
   break 终止循环
   continue 结束本次循环
'''
for i in range(7):
    if i == 6:
        print("<6")
        break
else:
    print(">6")
'''
 ----------------------------字符串-------------------------------
 字符串 带引号的内容 ‘ ‘ 、“ ”、''' '''都可以
 若字符串本身包含单引号，则用双引号，若包含双引号，则用单引号，或统一使用三引号
 字符串*3 => 重复
 输入： input()
    input函数得到的就是字符串
 输出： f-string、print()函数 %s
 下标：
    正数下标：第一个数开始，从零开始到+∞
    负数下标：最后一个数开始，从-1开始到-∞
    使用：变量[下标]
 切片：
    对操作的对象截取其中一部分的操作，字符串、列表、元组都支持切片操作
    语法：[起始：结束：步长] 到结束的前一位
    end 不写，则可以取到最后一个位置
    start不写，从第一个开始
    end start都不写， 冒号必须写
    步长可以是负数
    str[::-1]字符串逆置
 常见操作：
    find() 在字符串中查找是否存在某个字符串
        str.find(sub_str,start,end) 在str中查找sub_str,从start到end
        返回值：找到则为索引，没找到则为-1
        rfind 从右边（后边）开始查找
    index ：
        str.index(sub_str,start,end) 在str中查找sub_str,从start到end
        返回值：找到则为索引，没找到则报错
        rindex 从右边（后边）开始查找
    count() 统计出现的次数
        str.count(sub_str,start,end)
    replace()
        str.replace(str1, str2, count = str.count(str1))
        count : 替换次数，默认全部替换
        把str1替换成str2 
        返回值：得到一个新的字符串，不会改变原来的字符串
    split()
        str.split(sub,count) 将str字符串 以sub为分隔符分割count次
        返回值：一个列表[]
    join()
        str.join(str1) 将str插入到str1中每个元素之间，构造一个新的字符串
        str1：可迭代对象，可以将str添加到可迭代对象的两个元素之间
        如：
            "_".join("hello")
            结果：h_e_l_l_o
    capitalize 首字母大写
    title 每个单词首字母大写
    upper 所有字母大写
    lower 所有字母小写
    startswith 以什么开头
    endswith 以什么结尾
    lstrip 去除左边空格
    rstrip 去除右边空格
    strip  去除空格
    partition 分割
    
'''
name = "messi"
name = name * 3
print(name)

my_list = ["Lionel", "Andres", "Messi"]
print("_".join(my_list))
'''
 ----------------------------列表-------------------------------
 list []
    支持下标与切片 与字符串类似
    字符串不能通过下标修改列表中的数据，但是列表可以
    遍历：
        for/while
    添加操作： 都是直接在原列表中添加，不会返回新的列表
        append() 向列表尾部追加数据
        insert() list.insert(index) 在指定位置添加数据
        extend() list.extend(可迭代对象) 将可迭代对象中的每个数据添加到原来列表的末尾
    查询：
        列表中无find方法！！！！
        index() 根据数据值查找元素下标
        count() 统计出现次数
        in/not in 是否存在，存在true，否则false
    删除：
        del() del list[index] 删除下表为index的数据
        pop() 根据下标删除，默认删除最后一个数据（可指定下标），并返回删除的数据
        remove() 直接删除原列表中的数据，按值
    排序：
        前提：列表中的数据类型一致
        直接在原列表中排序
        sort() list.sort()
        sort(reverse = True ) 从大到小
        sorted(list):不会在原列表中排序，会得到一个新的列表
    逆置：
        list[::-1] 得到一个新列表
        list.reverse() 在原列表中排序
    enumerate() 带下标的遍历,将元素所在下标与元素数据组合在一起，变成元组
        for i in enumerate(list):
            print(i)
'''
# 定义空列表
my_list = []
my_list = list()
# 定义带数据的 ，数据之间用逗号隔开
my_list = [1, 3.14, True, "ISSSSS"]
my_list[-1] = "messi"
print(my_list)
# 遍历
for i in my_list:
    print(i)
# 添加
my_list.append("hello")
print(my_list)
my_list.insert(1, "d")
print(my_list)
b = [1, 2, "ddd"]
my_list.extend(b)
print(my_list)
# --------------------随机分房间案例--------------------
import random

names = ["A", "B", "C", "D", "E", "F", "G"]
room = [[], [], []]
for name in names:
    index = random.randint(0, 2)
    room[index].append(name)
for r in room:
    for n in r:
        print(n)
    print("*" * 30)
'''
 ----------------------------元组-------------------------------
    元组定义()
    元组中元素与列表类似，但是不能修改
    支持下标和切片
    定义一个元素的元组：(2,)一定要有逗号
 '''
# 定义空元组
tuplee = ()
# 定义一个元素的元组,
tuplee = (3,)

'''
 ----------------------------字典-------------------------------
 {}定义，key-value 键值对
 如: info = {'name' : 'messi','age' : 36} 一个 key:value 键值对是一个元素
 key可以是字符串/数字，不能是列表
  访问 ： 没有下标的概念，用key来访问value,如：
    info['name']，如果key值不存在，报错
    info.get('name') 如果key不存在，返回none，不会报错
    info.get(key,value) 如果key存在，返回key对应value值，若不存在则返回传入的value
  数据添加与修改：
    使用key值：
        字典[key] = 数据值； 如果key值存在，则为修改，若不存在则为新增。
        注意： key值的int 1与float 1.0为一个key值
  删除：
    根据key值删除   del my_dict[key] /  my_dict.pop(key)返回值是key对应的value值 key不存在会报错
    清空字典： 字典.clear() 
    删除字典 del 字典名
  遍历：
    for循环遍历:
        for key in my_dict2:
            print(my_dict2[key])
    字典.keys() 获取所有的key，得到的类型是dict_keys,可以用list()转换为列表，可用for循环遍历
    字典.values() 获取所有的value,得到的类型是dict_values 
    字典.items() 获取所有的键值对
        for k, v in dict.items():
            print(k,v)
'''
# 空字典
my_dict = {}
my_dict1 = dict()
# 有数据的字典
my_dict2 = {'name': 'messi', 'age': 36}
print(my_dict2.keys())
print(my_dict2.values())
print(my_dict2.items())
for key in my_dict2:
    print(my_dict2[key])
'''
 ----------------------------公共方法-------------------------------
 + 支持字符串、列表、元组进行操作，得到新容器
 *整数 支持字符串、列表、元组进行操作，得到新容器
 in/not in  判断存在或者不存在，支持字符串、列表、元组、字典进行操作
            注意：如果是字典，判断的是key值是否存在
 len(item)
 max(item) 对于字典来说比较的是key的值
 min(item)
 del(item) 
 '''
'''
 ----------------------------函数-------------------------------
 定义函数： def 函数名（参数）: #遵循规则，见名知意
            ‘’‘ 
            文档注释, 可以用help(函数名)来查看
            ‘’‘
            函数体
            return
  想要在函数体内部修改全局变量的值：要加global关键字
  
  return 返回多个数据值：将数据值放入容器中返回
 函数传参
    def func(a,b,c):
        print(f"a:{a}")
        print(f"b:{b}")
        print(f"c:{c}")
  位置传参: 按照形参的位置将实参的值传给形参
  func(1,2,3)
  关键字传参：指定实参传给哪个形参，注意点： 关键词必须是函数的形参名
  func(a=10,b=39,c=3)
  混合使用：先写位置参数，再写关键字参数
  func(10,b=90,c=8)√
  func(a=10,2,3) ×
 形参
  缺省参数：·
    形参，在函数定义时候，给形参一个默认值，这个形参就是缺省参数 
    注意:缺省函数要写在普通参数后面
  不定长参数：
    在形参前面加上一个*，其变为不定长元组形参，可以接受所有的位置实参，类型是元组
    在形参前面加上两个**，其变为不定长字典形参，可以接受所有关键字实参，类型是字典。
    def func(*args , **kwargs)
        print(args)
        print(kwargs)
  形参完整格式：
   普通形参、不定长元组形参、缺省形参、不定长字典形参
   如：def func(a,*args,b=1,**kwargs)
 拆包：
    组包：将多个数据值组成元组给一个变量： 如 a=1,2,3
    拆包：将容器中的多个数据给到多个变量，数据个数要与变量个数保持一致。
        所有容器都可以，字典是key值
    应用：
        交换两个变量： a,b = b,a
 引用：
    python中，值靠引用来传递
    可以使用id()查看变量的引用，可将id值认为是内存地址的别名
    赋值运算符可以改变变量的引用
 可变与不可变类型: 在不改变变量引用的前提下，能否修改变量中引用中的数据
    不可变：int float bool str tuple
    可变：list dict
    交互终端中，小整数（-5~255）使用相同的引用地址，如果不是小整数则开辟新的内存
    += 对于列表来说，类似extend方法，不会改变列表的引用地址
 递归：
    ①自己调用自己
    ②要有递归出口
 匿名函数： lambda关键字定义的函数为匿名函数
    lambda 参数列表：表达式
    1. 无参无返
        lambda ：函数代码
    2. 无参有返
        lambda ：表达式
    3. 有参无返 
        lambda a,b :print(a,b)
    4. 有参有返
        lambda a,b:a+b
 
 '''
# return 返回多个数据值
def func(a, b):
    c = a + b
    d = a - b
    return c, d  # 默认是组成元组进行返回.
aa, bb = func(10, 2)

# 匿名函数
# 1. 无参无返
def func1():
    print("hello")
(lambda: print("hello"))()  # 调用
f1 = lambda: print("hello")  # 调用
f1()
# 2. 无参有返
def func2():
    return 1+2
f2 = lambda :1+2
print(f2())
# 3. 有参无返
def func3(name):
    print(name)
f3 = lambda name:print(name)
f3("messi")
# 4. 有参有返
def func4(a,b):
    return a+b
f4 = lambda a,b :a+b
print(f4(3, 4))

#函数作为参数
def my_cal(a,b,func):
    print(func(a,b))
def add1(a,b):
    return a+b

my_cal(1,4,add1)

'''
        list排序
    list.sort(self,key,reverse) key用于指定排序规则
    
'''
list1 = [
    {'name':'fa','age':12},
    {'name': 'b', 'age': 12},
    {'name': 'c', 'age': 52},
    {'name': 'd', 'age': 12},
]
list1.sort(key = lambda x:x['age'])
# 如果有两种规则：
#       sort(key=lambda 形参：(排序规则1，规则2)）
list1.sort(key = lambda x :(x['age'],x['name']))
'''
    列表推导式：快速生成一个列表
    1. 变量 = [生成数据的规则 for 临时变量 in xxx]
    如：mylist = [i**2 for i in range(20)]
    2. 变量 = [生成数据的规则 for 临时变量 in xxx if xxx]
    3. 变量 = [生成数据的规则 for 临时变量 in xxx for j in xxx]
    如: mylist = [(i,j) for i in range(3) for j in range(2)]
    -------------------------------------------------------
    字典推导式：
    变量 = {生成数据的规则 for 临时变量 in xxx}
    my_dict = {key :value for i in range(3)
'''
'''
---------------------集合set---------------------
    定义： {数据，数据}
    特点： 
        1. 集合中数据必须为不可变类型，字典中的key也必须是不可变类型
        2. 集合是可变的
        3. 集合是无序的，不支持下标
        4. 集合是没有重复数据的，可以用来去重
    集合、列表、元组之间可以互相转换
'''
'''
    文件操作
    文件在硬盘中以二进制方式存储
    1. 打开文件
        open(file, mode='r', encoding=None)
        file要操作的文件名，类型是str
        mode文件打开的方式，r(read)只读打开，w(write)只写打开，a(append)追加打开
        encoding 文件编码格式 常见：GBK/UTF-8
        返回值：文件对象，后续所有文件操作都需要这个文件对象进行
    2. 读写文件
        文件对象.read()
        文件对象.readline()
        文件对象.readlines() 返回值是列表，列表中每一项是一个字符串，即一行的内容
        mode = ‘w'  文件对象.write(写入文件的内容)
    3. 关闭文件
        文件对象.close() 将内存中三大文件同步到硬盘中
    
  计算机最小单位：bit(位)，只有0/1 
  字节：基本单位byte
  1 byte = 8 bit   
    4. 二进制文件： 只能用二进制方式打开，不能指定encoding
        rb、wb、ab
    f.write('nihao'.encode()) encode将str转换为二进制格式的字符串
    buf.decode() 解码
    5. 文件备份
        只读打开文件
        读取文件内容
        关闭文件
        只写打开文件
        内容写入文件
        关闭文件
    找到后缀名. rfind('.')
'''

# 读文件
# file.read(n)一次读取n字节的内容，不写默认读取全部内容
file = open("1.txt")
buf = file.read()
file.close()
# 按行读取 file.readline() 一次读取一行的内容
# print(buf)
# 写文件 以w方式打开文件，若文件不存在会创建，若文件存在则会覆盖原文件
file = open('a.txt','w')
file.write("hello messi")
file.close()
 # 以a方式打开文件，追加内容，在文件的末尾写入内容，写入也用write
file = open('a.txt','a')
file.write("lionel andres messi")
file.close()
# 读取大文件
while True:
    buf = file.readline()
    if buf:
        print(buf,end=' ')
    else:
        break

# 无换行
while True:
    buf = file.read(4096)
    if buf:
        print(buf, end=' ')
    else:
        break

记录学习~~~