python基础

1.标识符

标示符：就是变量、函数的名字
要求：由 字母、下划线 和 数字 组成
不能以数字开头
不能与关键字重名
不建议用类型(int、str、float)作为标示符名字

2.格式化输出

# 定义整数变量 student_no
student_no = 1
# %d占位，输出整型
# %06d 6位，不够前面补0
print("我的学号是%06d" % student_no)

price = 9.0
weight = 5.0
total_price = 45.0

# %f, 默认小数点后6位
# %.2f, 小数点后2位
# crtl+d   快速复制1行

print("苹果单价 %f 元／斤，购买了 %f 斤，需要支付 %f 元"%(price, weight, total_price))
print("苹果单价 %.2f 元／斤，购买了 %.2f 斤，需要支付 %.2f 元"%(price, weight, total_price))

a = 80
# 占用率位：80%, 两个%%输出1个
print("占用率位：%d %%"%a)

3.break和continue的使用

相同点：都是跳出循环
不同点：break直接跳出循环，不再运行continue, 跳过本次循环，下次继续执行

# break, 跳出循环，如果有多循环嵌套，作用于最近的内循环，就近原则
# break只能用于循环

# continue, 跳出当前这1次循环，下一次继续， 如果有多循环嵌套，作用于最近的内循环，就近原则
# 只能用于循环

4.列表

"""
列表.append(值) 在末尾追加数据
列表.remove(值) 删除第一个出现的指定数据
"""


"""
列表[索引] = 值 修改指定索引的数据，数据不存在会报错
列表[索引]         根据索引取值，索引不存在会报错
len(列表)     列表长度(元素个数)
if 值 in 列表: 判断列表中是否包含某个值
"""
# 列表.sort() 升序排序
num_list = [1, 5, 2, 6, 3]

num_list = [1, 5, 2, 6, 3]
# reverse=True, 降序
num_list.sort(reverse=True)
print(num_list)

5.字符串

查找
"""
字符串.find(目标字符串, 开始索引, 结束索引) 在指定范围内, 查询目标字符串的索引, 不存在返回-1
"""
str1 = 'hello abc mike'
pos = str1.find('abc')
print(pos)
# 如果没有找到，返回-1
pos = str1.find('py')
print(pos)

替换
"""
字符串.replace(原内容, 新内容, 替换次数)  返回一个替换了原内容的新字符串，可以指定替换次数
"""
# 源字符串里的abc，替换为python，返回值才是替换后的内容
new_str = str1.replace('abc', 'python')

分隔
# 字符串.split(分割符) 以分割符拆分字符串, 返回列表
str1 = 'abc,hello,mike,python'
str_list = str1.split(',')
print(str_list)

拼接
"""
字符串 + 字符串         拼接两个字符串
字符串.join(字符串列表) 以字符串来连接字符串列表中每个元素，合并为一个新的字符串, 返回新的字符串
"""
str_list = ['abc', 'hello', 'mike', 'python']
str2 = '++hehe++'

new_str = str2.join(str_list)

6.可变类型与不可变类型

可变类型：列表list, 字典dict, 集合set
不可变类型：int、float、bool、字符串str、元组tuple

"""
可变类型: 列表、字典、集合
不可变类型: 数字类型(int, bool, float)、字符串
只要重新赋值新的数据，都是改变内存地址，都会重新分配内存
"""

7.匿名函数

# 格式
# lambda 形参1, 形参2：单行代码或者函数调用
lambda a, b: a+b
# 调用方式
# 1. (匿名函数整体)(所需的参数)
# 2. f = 匿名函数整体   # 给匿名函数起名
#    f(所需的参数)

8，文件读取

1.read读数据
# 2. 读取文件内容
# 格式： 内容变量 = 文件变量.read(读取的长度)
# 如果read的长度不指定，默认读取全部
ret = f.read(5)
print(ret)
# 下次，继续接着上一次的位置
ret = f.read(4)
print(ret)

2.readlines读数据
# readlines: 读取所有的行，按行作为分隔条件
# 格式：内容列表变量 = 文件变量.readlines()
content_list = f.readlines()
# '\n'换行符，代表换行
print(content_list)
# 通过for取出列表的所有元素
for v in content_list:
    print(v)

3.通过readline读数据
# 2. 读取文件内容
# readlines： 读取所有的行
# readline:   一次读取一行
# readline格式：内容变量 = 文件变量.readline()
content = f.readline()
print(content)
content = f.readline()
print(content)

# 打开文件，指定编码， encoding=编码格式
f = open('666.txt', 'w', encoding='utf-8')
# 写文件的时候和读文件，使用同一个编码方式即可

9.文件相关操作

import os
# 文件重命名： os.rename(旧名字，新名字)
# 删除普通文件：os.remove(待删除文件的名字)
# 创建文件夹： os.mkdir(文件夹名字)
# 删除空文件夹：os.rmdir(待删除文件夹名字)
# 获取当前路径：路径变量 = os.getcwd()
# 切换路径：  os.chdir(需要切换的路径)
# 获取目录信息：目录列表变量 = os.listdir(指定某个目录) [重点]

10 eval的使用

# 通过eval()做转换：看到字符串像什么，就转换为什么
str1 = "['a', 'b', 'c']"
print(str1, type(str1))
temp1 = eval(str1)
print(temp1, type(temp1))

11.面向对象

1.__init__
"""
`__init__`方法：
    1. 作用：添加属性
    2. 特点：创建对象的时候，实例化对象，自动调用__init__方法
    3.  设置参数，调用的使用需要和__init__参数匹配
        对象名 = 类名(实参1， 实参2) ====》 __init__(self, 形参1, 形参2)
"""
2.__str__
"""
__str__方法:
    1. 返回值必须是字符串
    2. print(对象变量名)  打印__str__方法返回值
"""
3.__del__
"""
__del__方法：函数调用完毕、程序结束，对象生命周期结束，系统会自动调用__del__方法，做清理工作
"""


"""
私有属性：
    1. __(2个下划线)开头的属性，就是私有属性
    2. 只能在类内部操作，在类的外面无法直接操作
"""class Dog(object):
    # 添加一个私有属性
    def __init__(self):
        self.__baby_count = 0
        self.age = 1
"""
私有方法：
    1. __(2个下划线)开头的普通方法，就是私有方法
    2. 只能在类内部操作，在类的外面无法直接操作
    3. 在类的内部调用普通的实例方法，格式：self.方法名()
"""
 # 定义一个私有方法
    def __leave(self):
        print('休产假了')

5.子类调用父类的属性和方法

    def print_type(self):
        # 在子类的内部，调用父类的方法
        # 1. 父类名字.方法名(self)
        # Animal.__init__(self)
        # 2. super(子类名字, self).方法名()
        # super(Dog, self).__init__()
        super().__init__() # 等价于 Animal.__init__(self)
        super().print_type() # 等价于 Animal.print_type(self)
        print('Dog类中的print_type = ', self.type)


6.属性和方法
"""
实例属性：放在__init__中添加的属性，或者，直接在类的外面添加的属性（对象名.属性 = 数据）
类属性：直接在类里面，方法的外面，定义的变量
实例属性只属于某个对象，类属性属于类的，也是所有对象共有的
"""
# 普通方法：在外部，对象名.方法名()
# 类方法：类名.类方法名(), 主要为了处理类属性，同样可以通过对象名操作
"""
类方法格式：在平时写函数的外面加上@classmethod
          默认增加一个参数，代表class的缩写，代表类名，这个参数只能访问类属性
"""
# 静态方法: 一个和实例属性、类属性没有关系的方法，就是在类中普通的方法
# 调用方式：类名.方法名() 或者 对象名.方法名()
class Dog(object):
    @staticmethod
    def normal_func():
        print('一个和实例属性、类属性没有关系的普通方法')

11.异常和模块

异常：不是语法错误，语法错误，是程序写错了
异常：指程序已经运行了(没有语法错误)，突然发生异常，导致程序崩溃
try:
    # ret = f.read()
    # print(ret)
    f.write('hello mike')
    print('='*20)
except Exception as e:
    print('产出异常：', e)
else:
    print('没有产生异常')
finally:
    print('关闭文件')
    f.close()

2.异常的传递
由内向外传递


# 导入模块：本质上就是导入文件名
# 模块：就是一个py文件，模块里面有：函数的定义，类的定义，全局变量
# 导入模块（导入这个py文件）后，可以使用文件里面的代码
# 模块：管理代码的一个文件

__name__的作用
作用：为了判断模块代码是否直接运行，或者通过导包间接运行
如果模块文件直接运行，__name__内容为__main__如果通过导包间接运行：__name__内容不是__main__

模块中的__all____all__：只针对from 模块 import *有效，__all__里面的元素才能被外面使用