python基础知识笔记

1、Linux下文件结构

Linux没有盘的概念，只有一个根目录，所有文件都在它下面

常用Linux的命令

1、ls: 查看当前文件夹下的文件

2、pwd:查看当前所在文件夹

3、cd 目录名：切换文件夹

4、touch 文件名：如果文件不存在，新建文件

5、mkdir 文件名:创建目录，文件夹

6、rm 文件名:删除指定文件名，不能删文件夹

7、clear:清屏

终端命令格式

command 【-options】 【parameter】，中括号表示可选择

command：命令名，相应功能的英文单词或单词的缩写，直接回车就可以执行

【-options】：选项，可用对命令进行控制，也可以省略

【parameter】：传给命令的参数，可以是零个，一个等

rm -r 文件夹名：删除文件夹

command --help：显示命令的帮助信息

man command：查阅使用手册（manual缩写）

终端使用技巧

1、自动补全

在敲出 文件/目录/命令的前几个字母之后，按下Tab键。

如果输入的没有歧义，系统会自动补全

2、曾经使用过的命令

按上下光标键可以在曾经使用过的命令之间来回切换，如果想要退出就按ctrl + c

linux 下文件和目录的特点

1、文件或目录名称最长有256个字符

2、以 ‘ . '开头的文件为隐藏文件，需要用-a参数才能显示

3“.”代表当前目录，“…"代表上一级目录：cd … 回到上级目录

ls常用选项

-a 显示指定目录所有子目录与文件，包括隐藏文件

-l 以列表方式显示文件的详细信息

-h 配合-l 以任性画的方式显示文件大

1 *代表任意个数字符；例如ls 1 * (显示以1开头的文件)

2 ？代表一个字符；例如ls 1？（显示以1开头后面接一个字符的文件）

3 【】代表字符组【abc】【a-f】等

cd 命令

拷贝与移动文件

cp ~/Document/123.txt .：将Document/123.txt文件复制当前目录下

mv 源文件 目标文件

查看文件内容

查看配置网卡信息

SSH远程控制

2、python的学习

运算符

+	加
-	减
*	乘
/	除
//	取整除
%	取余数
**	幂次

算数运算优先级

程序执行的原理

程序要执行，先从硬盘加载到内存中，再在CPU中执行

不同数据类型之间的计算

1数字型变量

1、数字型变量可以直接计算，如果变量是bool型，True=1,False=0;

2字符串型变量

1、字符串之间可以用+号拼接

2、字符串变量可以与整数使用 * 重复拼接字符串

3、数值型变量不能与字符串型进行其他非乘运算

input函数实现键盘输入

用户输入的任何内容，python都视为：一个字符串

语法：字符串变量 = input （“输入内容”）

类型转换函数

int（x）:将x转化成一个整数

float(x)：将x转化成一个浮点数

变量的格式化输出

变量的命名规范

1标识符与关键字

标识符：是程序员定义的变量名，函数名；可以由字母，下划线，数字，但是不能以数字开头，不能与关键字重名

关键字：内部已经使用的标识符，具有特殊功能和含义

变量命名的规则

1、定义变量，在=左右各保留一个空格

2、变量名由一个或两个单词组成，都使用小写；单词之间下划线连接；

3、由多个单词组成，按驼峰命名法，首字母大写：FirstName

python 更喜欢下划线连接

比较运算符

逻辑运算符

运算符包括：and与， or或， not非

9*9乘法表

row = 1

while row <= 9:
    col = 1
    while col <= row:
        print('%d * %d =%d' % (col,row,col*row),end='\t')#加end不希望换行
        col += 1
    print('')
    row += 1

转义字符

\t:制表符

\n:换行

3、函数的定义

def 函数名（）：

​ 函数体

函数的演练

def say_hello():
    print("hello 1")
    print("hello 2")
    print("hello 3")
say_hello()

调用函数：函数名（）

函数形参和实参

函数的返回值return

return表示返回，后续的代码都不会被执行

函数内部return表示函数内结束，外面表示外面结束

函数里调用另一个函数，叫做函数的嵌套

函数的模块调用

4、列表

列表的定义

1、存储一串信息

2、用【】定义，数据之间用，隔开

3索引从0开始

列表常用小操作

name_list.index(“lisi”),查询列表“lisi”的下标索引，传递的数据不在列表中则会报错

name_list = ['张三','李四','王五']
#取值和去索引
print(name_list[0])
print(name_list.index('王五'))
#修改
name_list[1]='lisi'
#增加
name_list.append('王二小')#在列表末尾追加元素
#insert方法在列表指定的位置插入数据
name_list.insert(1,'小妹妹')
#extend插入新列表,接在后面
t_list = ['孙悟空','猪八戒']
name_list.extend(t_list)

#删除
name_list.remove('王五')
name_list.pop()#默认删除最后一个
name_list.pop(1)#删除指定
name_list.clear()#清空列表
print (name_list)

del （一个空格）列表 【索引值】：删除列表指定索引的数据

len(name_list)#统计列表元素总数
name_list.count(‘张三’)#统计某个元素出现次数

name.list.remove(‘张三’)#删除出现的第一个相同元素

列表的排序翻转

列表.sort()#升序，从小到大

列表.sort(reverse=True)#降序，从大到小

列表.reverse()#元素的反转

name_list = ['zhangsan','lisi','wangwu']
num_list = [6,8,4]
#升序
# name_list.sort()#按英文首字母顺序
# num_list.sort()#按数字大小顺序
#降序
# name_list.sort(reverse=True)
# num_list.sort(reverse=True)
#逆序
name_list.reverse()
num_list.reverse()

print(name_list)
print(num_list)

列表的循环遍历

name_list = ['张三','李四','王宇']
for name in name_list :
    print(name)

列表应用场景

1、列表可以存储不同数据类型，通常存储相同的数据

2、通过迭代遍历，对每个元素执行相同操作

元组，不可变列表，

定义用小括号，只有一个元素，后面加，号

1、索引：元组的索引和列表一样，tuple[0]

2、定义空元组，empty_tuple = (),后面接一个小括号，一般不推荐建立空元组，因为不能修改

3、定义单个元素的元组，在元素后面加逗号，不然python会忽略（）

元组的遍历

元组的应用

格式化字符串后面可以用元组代替

关键字，函数，方法的区别

关键字33个

5、字典

字典的遍历

遍历就是依次从字典中获取所有键值对

for k in xiaoming:
    print("%s:%s"(k,xiaoming{k}))

字典应用场景

1、使用多个键值对，存储描述一个物体的相关信息

2、将多个字典放在一个列表，再进行遍历，在循环体对每一个字典进行相同处理

card_list = [
    {'name':'zhangsan',
    'qq' : '123'},
    {
        'name':'lisi',
        'qq' : '456'}
]

字典中保存的数据是无序的，列表中数据是有序的

caed_list = [
    {"name":"张三",
     "qq":"123",
      "phone":"110"},
    {"name":"李四",
     "qq":"321",
      "phone":"10086"}
    ]
for caed_info in caed_list:
    print(caed_info)

字典的定义

1、字典可以存储多种数据

2、字典使用键值对存储数据，键值对之间用，分割。

3、值可以取任何数据类型，但键只能使用字符串、数字、元组，键的名字唯一

4、字典中保存的数据是无序的，列表中数据是有序的

字典的增删改查

1、取值dict[k]

2、增加、修改，如果k不存在，会新增键值对；如果存在，则修改值dict[k] = 值

3、删除,指定k就行 pop(k)

xiaoming_dict = {
    "name" : "小明"
}
#1取值
print(xiaoming_dict["name"])
#2增加、修改，如果k不存在，会新增键值对；如果存在，则修改值
xiaoming_dict["age"] = 18#增加
xiaoming_dict["name"] = "小小明"#修改

#3删除,指定k就行
xiaoming_dict.pop("name")

字典的统计、合并、清空

1、统计键值对数目，用len

2、合并字典,使用.update(字典名)

3、清空字典，用clear

xiaoming_dict = {
    "name" : "小明",
    "age": 18
}
#1、统计键值对
print(len(xiaoming_dict))
#2合并字典,使用.update(字典名)
#注意使用update，被合并字典中包含存在键值对，会覆盖原来
temp_dict = {"height":1.75}
xiaoming_dict.update(temp_dict)
#3清空字典
xiaoming_dict.clear()
print(xiaoming_dict)

6、字符串的定义

for循环拿出字符串每一个字符

string = "hello python"
for i in string:
    print(i)

字符串的常用操作

1、统计字符串长度len

2、.count（字符串）：统计小字符串在大字符串中出现次数

3、字符串索引，从字符串中取出单个字符

4、.index(字符串)：获得小字符串第一次出现的索引

hello_str = 'hello hello'
#1、统计字符串长度
print(len(hello_str))
#2、统计某个小字符串出现次数,用.count('')
print(hello_str.count('llo'))
#3、某一个子字符串出现的位置,只输出第一次出现索引
print(hello_str.index('llo'))

1、判断类型-9

#1、判断是否只包含空白符包括\t,\r,\n
space_str = ' \t\r\n'
print(space_str.isspace())

#2判断字符串中是否只包含数字
#这三种方法都不能判断小数
num_str = '1'
print(num_str.isdecimal())#只能判断数字
print(num_str.isdigit())#数字，Unicode数字如‘\u00b2’，序号(1)
print(num_str.isnumeric())#数字和中文数字如‘一千零一’

2、字符串的查找和替换-7

hello_str = 'hello world'
#1、判断是否以指定字符串开始.startswith()区分大小写
print(hello_str.startswith('hello'))
#2、判断是否以指定字符串结尾。endswith('world')
print(hello_str.endswith('world'))
#3、查找指定字符串，.find('hello')指查找字符串的索引
#.index()查找不存在会报错，find会出现-1
print(hello_str.find('2llo'))
print(hello_str.index('llo'))
#4、替换字符串.replace('old_str','new_str')
#replace执行完之后，会返回一个新字符串，不会修改原有字符串的内容
print(hello_str.replace('world','python'))
print(hello_str)

3、文本对齐-3

poem = [
    '登鹳雀楼',
    '王之涣',
    '白日依山尽',
]
#按照顺序输出字符串
#。center(wight,fillchar),fillchar可以加中文空格
for i in poem:
    # print('|%s|'%i.center(10,'　'))#居中
    # print('|%s|' % i.ljust(10, '　'))  # 左对齐
    print('|%s|' % i.rjust(10, '　'))  # 右对齐

4、去除空白字符-3

poem = [
    '\n登鹳雀楼',
    '王之涣\t',
    '白日依山尽',
]
#按照顺序输出字符串
#。center(wight,fillchar),fillchar可以加中文空格
for i in poem:
   
    #先使用strip方法去除字符串的空白字符
    #再使用center方法居中文本
    print('|%s|' % i.strip().center(10, '　'))  # 右对齐

5、字符串的连接和拆分-5

#1去掉空白字符
#2使用‘ 空格’作为分隔符，拼接一个整齐的字符串
poem = '登鹳雀楼\n 王之涣 \t'
print(poem)

#1拆分字符串,split结果返回一个列表型字符串
#不指定分隔符，默认\r\t\n和空格
list= poem.split()
print(list)
#2、合并字符串，用‘ ’做分隔符,','.join前指定分隔符
str = ' '.join(list)
print(str)

字符串的切片

1、切片的方法用于字符串、列表、元组

7、高级数据的公共方法

内置函数

a = [1,2,3]
del a[1]#用关键字方式删除元素
print(a)
del(a[1])
print(a)#用函数方式删除
#求最大字符
t_str = 'abcdefg'
print(max(t_str))#最大字符
print(min(t_str))#最小字符
#统计字典大小，只会比较k值
t_dict = {'a':'z',
          'b':'y',
          'c':'x'}
print(max(t_dict))#字典求最大，只会返回k值最大
#cmp(a,b)比较两个大小,python3.0删除cmp
print('1'<'2')
#字典不能直接用算数运算符比较大小

切片

a = [0,1,2,3,4]#列表切片
print(a[1:3])
b = (0,1,2,3,4)#元组切片
print(b[1:3])
#不能对字典切片，因为字典是无序集合

运算符

#*乘号，重复操作
a=(1,2)*2
print(a)#元组重复，重复是内部的内容
#字典不可重复，因为字典k是唯一，k不能重复
#+号，合并拼接，字符串，列表，元组
print('hel'+'lo')#拼接
#+号和列表中extend很像
b = [1,2]
b.extend([3,4])
#append传递列表，传递元素会被当成一个整体
b.append([3,4])#输出[1, 2, 3, 4, [3, 4]]
print(b)
#in成员运算符，字符串列表元组字典，
print('a' in 'abc')#返回true
print('a' in {"a":"abc"})#字典判断是否存在k

完整for循环语句

student = [
    {'name':'xiaomei'},
    {'name':'xiaoming'}
]
#搜索学员列表中指定名字
find_name = 'xiao'

for stu_dict in student:
    print(stu_dict)
    if stu_dict['name'] == find_name:
        print("找到了 %s" % find_name)
        #如果找到指定名字，应该退出循环
        break
else:
    print("抱歉没有找到 %s"% find_name)
print("循环结束！")

for循环带下标

list = ['a','b','c'] 
for index ,v in enumerate(list):
    print(index)
    print(v)

8、综合应用–名片管理系统

card_main

import card_tools
#无限循环，由用户主动决定什么时候退出循环
while True:
    # TODO 显示功能菜单
    card_tools.show_menu()
    action_str = input("请选择希望执行的操作：")
    print("您选择的操作是【%s】"%action_str)
    #如果是123是针对名片的操作，是0就退出；其他内容是输入错误
    if action_str in ['1','2','3']:#判断是否在这个成员里
        #新增名片
        if action_str == '1':
            card_tools.new_card()
        #显示全部
        elif action_str == '2':
            card_tools.show_all()
        #查询名片
        elif action_str == '3':
            card_tools.search_card()
    #0退出系统
    elif action_str == '0':
        print("欢迎再次使用【名片管理系统】!")
        break
    #其他内容提示错误
    else:
        print("您的输入有误，请重新输入！")

card_tools

#定义空列表，存放字典信息
caed_list = []
def show_menu():
    '''显示菜单'''
    print("*"*50)
    print("欢迎使用【名片管理系统】 V 1.0")
    # print("")
    print("1.新增名片")
    print("2.显示全部名片")
    print("3.查询名片")
    print("")
    print("0.退出系统")
    # print("")
    print("*"*50)

def new_card():
    '''新增名片'''
    print('-'*50)
    print('新增名片')
    #1.提示用户输入名片信息，
    name = input("请输入姓名：")
    phone = input("请输入电话：")
    qq = input("请输入邮箱：")
    #2.使用用户输入的信息建立一个字典
    card_dict = {"name":name,
                 "phone":phone,
                 "qq":qq}
    #3。将名片添加到字典,append把追加元素当一个整体
    caed_list.append(card_dict)
    print(caed_list)
    #4.提示用户添加成功
    print("添加%s的名片成功！"%name)


def show_all():
    '''显示所有名片'''
    print('-' * 50)
    print('显示所有名片')
    #判断是否存在名片，提示用户，并且返回
    if len(caed_list) == 0:
        print("当前没有任何的名片信息,请先添加名片信息！")
       #return可以返回一个函数执行结果，同时功能是下方代码不会被执行
        return
    #遍历列表，依次输出字典信息
    #打印标头，
    for name in ['姓名','电话','qq']:
        print(name,end = '\t\t')#不换行，后面接end=
    print('')
    # 打印分割线
    print('='*50)
    for card_dict in caed_list:
        print('%s\t\t%s\t\t%s\t\t'%(card_dict['name'],
                                    card_dict['phone'],
                                    card_dict['qq']))

def search_card():
    '''搜索名片'''
    print('-' * 50)
    print("搜索名片")
    #1.提示用户输入要查询的姓名
    find_name = input("请输入要查询姓名：")
    #2.遍历名片列表，查询搜索姓名；没有找到提示用户没查询到
    for card_dict in caed_list:
        if card_dict['name'] == find_name:
            for name in ['姓名', '电话', 'qq']:
                print(name, end='\t\t')  # 不换行，后面接end=
            print('')
            # 打印分割线
            print('=' * 50)
            for card_dict in caed_list:
                print('%s\t\t%s\t\t%s\t\t' % (card_dict['name'],
                                              card_dict['phone'],
                                              card_dict['qq']))
            # TODO后续增加修改删除的功能
            deal_card(card_dict)
            break
    else:
        print('抱歉，没有找到%s'% find_name)

def deal_card(find_dict):
    print(find_dict)
    #提示用户输入数字，1：修改；2.删除；0：返回上一行
    action_str = input("请选择要执行的数字 "
                       "【1】 修改 【2】 删除 【0】 返回上级菜单")
    if action_str == '1':
        find_dict['name'] = input_card_info(find_dict['name'],'姓名【按回车不修改】:')
        find_dict['phone'] = input_card_info(find_dict['phone'],'电话【按回车不修改】:')
        find_dict['qq'] = input_card_info(find_dict['qq'],'qq【按回车不修改】:')
        print("修改名片成功1")
    elif action_str == '2':
        caed_list.remove(find_dict)#删除列表中字典
        print('删除名片成功！')

def input_card_info(dict_value,tip_message):
    """输入名片信息

    :param dict_value:字典中原有的值
    :param tip_message:输入的提示文字
    :return:如果用户输入了内容，返回内容；否则不变
    """
    #1.提示用户输入内容
    result_str = input(tip_message)
    #2.针对用户输入内容进行判断，
    if len(result_str) > 0:
        return result_str
    # 如果用户输入内容，直接返回结果；没有输入内容，则不变
    else:
        return dict_value

9、linux上shebang符号#！

10、变量的进阶理解

a = 1 #看到赋值语句，注意力放右侧
#变量a存储的是数字1的地址
print(id(a))#数字1的地址
print(id(1))#数字1的地址
b = a
print(id(b))#数字1的地址

调用函数传递实参的引用

可变和不可变类型

#对列表进行操作，ID地址不变
a = [1,2,3]
print(id(a))
a.append(999)
print(id(a))
a.remove(2)
print(id(a))
#字典的ID地址不变
d = {'name':'小明'}
d['age'] = 18
print(id(d))
d.pop('age')
print(id(d))

#对列表进行操作，ID地址不变

#字典的ID地址不变

注意：字典的K只能用不可变类型数据

hash哈希

hash只能传递不可变数据类型的特征码

局部变量和全局变量

def demo1 ():
    num = 10
    print("在demo1中函数的局部变量是%d"%num)
#在函数内部定义的变量，不能在其他位置使用
print(num)#name 'num' is not defined
demo1()

在函数内部修改全局变量值

num = 2
def demo1():
    print('demo1 ==> %d'% num)#输出2
def demo2():
    #如果希望修改全局变量，使用global声明一下变量即可
    global num
    num = 3
    print('demo2 ==> %d' % num)#输出3
demo1()
demo2()

全局变量定义的位置与代码结构

在开发中，应该把所有模块的所有全局变量。定义在函数上方

全局变量命名的建议

函数参数和返回值的作用

def measure():
    '''测量温度和湿度'''
    print('测量开始...')
    temp = 39
    wetness = 50
    print('测量结束。。')
    #使用元组返回多个变量,可以省略小括号
    return temp,wetness#(temp,wetness)元组
result = measure()#返回值是元组(39, 50)
print(result)

使用元组返回多个变量,可以省略小括号

返回值是元组(39, 50)

可变和不可变参数

在函数内部赋值不影响外部实参

def demo(num):
    print("函数内部的代码")
    #在函数内部，针对参数使用赋值语句，不会修改到外部的实参变量
    num = 100
    print(num)
    print("函数执行完成")
gl_num = 99
demo(gl_num)
print(gl_num)

在函数内部，如果参数是可变，使用方法修改数据内容，会影响外部的数据

+=操作

def demo(num,num_list):
    print("函数开始！")
    #执行的num = num + num，不会改变全局变量
    num += num
    #列表+= ，执行extend方法
    num_list += num_list
    print(num)
    print(num_list)
    print("函数完成！")
gl_num = 9
gl_list = [1,2,3]
demo(gl_num,gl_list)
print(gl_num)
print(gl_list)

列表和字符串依旧执行的是赋值操作

缺省操作

gl_list = [6,3,9]
#sort()不指定参数，默认按升序
# gl_list.sort()
#降序，指定参数reverse=True
gl_list.sort(reverse=True)
print(gl_list)

将常见的值设置为参数的缺省值，从而简化函数的作用

指定函数的缺省参数

def print_info(name,gender=True):
    """
    :param name:同学姓名
    :param gender:True 男生，False 女生
    """
    gender_text = '男生'
    if not gender:
        gender_text = '女生'
    print('%s是%s'%(name,gender_text))
print_info('小明')#执行默认值
print_info('小美',False)

注意事项

多值参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IfHk38Xu-1661998025513)(D:\Program Files\Typora\python图片\image-20220511200842861.png)]

def demo(num,*nums,**person):
    print(num)
    print(nums)
    print(person)
demo(1)
# demo(1,2,3,4,5)#输出1,(2, 3, 4, 5)，{}，将2345看成元组
#键值对name='小明',age = 18指定到字典中
demo(1,2,3,4,5,name='小明',age = 18)

多值参数的案例

def sum_numbers(*args):
    num = 0
    print(args)
    #循环遍历对元组进行累加
    for i in args:
        num += i
    return num
result = sum_numbers(1,2,3,4,5)
print(result)

在调用方法，元组变量前，增加一个;字典变量加***

函数的递归

#求阶乘
def sum_number(n):
    if n>1:
        return n*sum_number(n-1)
    else:
        return 1

    # print(num)
    #递归出口，当参数满足某个条件时，不再执行
print(sum_number(6))

#累加操作
def sum_numbers(num):
    #1.首先考虑出口
    if num > 1:
        return num+sum_numbers(num-1)
    #数字累加
    else:
        return 1

print(sum_numbers(8))

11、面向对象的基本概念

面向过程流程

面向对象流程

类和对象

面向对象的基本语言

dir(数据，变量，函数)：回车，出现内置方法

如：demo._ _doc _ _，运行文档方法

定义简单的类（只包含方法）

方法和函数的区别：方法的第一个参数一定是self

def 方法名 （self,参数列表）：

class Cat:
    def eat(self):#定义方法，有参数self
        print('小猫爱吃鱼！')
    def drink(self):
        print('小猫要喝水！')
#创建对象
tom = Cat()
#让对象调用一下类里的方法
tom.eat()
tom.drink()

上面的tom（对象变量)就是引用创建对象的地址，

print（tom(对象变量)）,输出类名、具体对象、内存地址16进制

如：<main.Cat object at 0x0000014219017520>

同一个类创建的多个对象是不同对象，内存地址不同

方法中的self参数

给对象增加属性，可以使用.属性名，利用赋值语句就可以

哪一个对象调用的方法，self就是哪一个对象的引用

class Cat:
    def eat(self):#定义方法，有参数self
        print('%s爱吃鱼！' % self.name)
    def drink(self):
        print('%s要喝水！'%self.name)
#创建对象
tom = Cat()
tom.name = 'TOM'#给对象赋属性
#让对象调用一下类里的方法
tom.eat()
tom.drink()
print(tom)

在类的外界设置对象属性的隐患

class Cat:
    def __init__(self):
        print("初始化方法！")
        #self.属性名 = 属性的初始值,创建对象就会继承属性
        self.name = 'TOM'
#使用类名（）创建对象，会自动调用初始化方法__init__
tom = Cat()#创建对象
print(tom.name)

使用参数设置属性初始值

class Cat:
    def __init__(self,new_name):#设置一个参数，接收对象的属性
        print("初始化方法！")
        #self.属性名 = 属性的初始值,创建对象就会继承属性
        self.name = new_name
#使用类名（）创建对象，会自动调用初始化方法__init__
tom = Cat('TOM')#创建对象
print(tom.name)#对象的属性名
lazy_cat = Cat('大懒猫')
print(lazy_cat.name)#对象的属性名

内置方法和属性

class Cat:
    def __init__(self,new_name):
        self.name = new_name
        print('%s 来了'% self.name)
    def __del__(self):
        print('% s 我走了'%self.name)
#tom是一个全局变量
tom = Cat('TOM')
print(tom.name)#打印对象的属性
del tom#可以删除对象，这样下划线才在最下面输出
print('-'*50)#下划线在tom上方输出

class Cat:
    def __str__(self):
        #必须返回一个字符串
        return '我是小猫'
#tom是一个全局变量
tom = Cat('TOM')
print(tom)#打印对象的属性

1、面向对象封装案列

小明爱跑步

class Person:
    def __init__(self,name,weight):
        self.name = name#self调用属性，后面跟上形参名
        self.weight = weight
    def __str__(self):
        return '我的名字叫%s,体重是%.2f公斤' %(self.name,self.weight)
    def run(self):
        print('%s爱跑步，跑步锻炼身体！'%self.name)
        self.weight -= 0.5
    def eat(self):
        print('%s是吃货，吃完这顿再减肥！'%self.name)
        self.weight += 1
xiaoming = Person('小明',56.2)
xiaoming.run()
xiaoming.eat()
print(xiaoming)

添加家具

class HouseItem:#定义家具类
    def __init__(self,name,area):#初始化方法中定义属性
       self.name = name
       self.area = area

    def __str__(self):
        return '[%s]占地 %.2f平方米'%(self.name,self.area)


class House:
    def __init__(self,house_type,area):
        self.house_type = house_type
        self.area = area
        #还有两个属性，剩余面积，和家具名称列表
        self.free_area = area#初始值等于总面积
        #家具名称列表
        self.item_list = []#初始值的空
    def __str__(self):
        return ('户型： %s\n总面积：%.2f平方米[剩余面积：%.2f平方米]\n家具：%s'
                %(self.house_type,self.area,
                  self.free_area,self.item_list))

    def add_item(self,item):
        print("要添加的%s" % item)
        #判断家具的面积是否超过剩余面积，如果超过，提示不能添加这件家具
        if item.area > self.free_area:
            print("%s的面积太大了，无法添加"% item.name)
            return
        #2.将家具的名称追加到家具名称列表中
        self.item_list.append(item.name)
        #3.用房子的剩余面积-家具面积
        self.free_area -= item.area

#1、创建家具对象
bed = HouseItem('席梦思',40.0)
chest = HouseItem('衣柜',2)
table = HouseItem('餐桌',20)
#2、创建房子对象
my_home = House('两室一厅',60)
my_home.add_item(bed)
my_home.add_item(chest)
my_home.add_item(table)
print(my_home)

士兵突击

一个对象的属性，可以是另一个类创建的对象

class Gun:
    def __init__(self,model):#子弹数量不需要初始化属性
    #1.枪的型号
        self.model = model
    #2.子弹的数量,初始化0
        self.bullet_count = 0
    def add_bullet(self,count):#定义添加子弹
        self.bullet_count += count
    def shoot(self):#定义发射子弹
        #1判断有没有子弹
        if self.bullet_count <=0 :
            print("[%s] 没有子弹了。。。"%self.model)
            return
        #2.发射子弹，数量减1
        self.bullet_count -= 1
        #3.提升发射信息
        print("[%s] 突突突。。。剩余[%d]发"%( self.model,self.bullet_count))


class Soldier:
    def __init__(self,name):#新兵没有枪，所有不需要定义枪的属性
        #1新兵的姓名
        self.name = name
        #2枪
        self.gun = None#不知道设置什么类型，新兵没有枪，所有设置None
    def fire(self):
        #1判断士兵有没有枪
        if self.gun == None:
            print("【%s】还没呀枪"% self.name)
            return
        # 2高喊口号
        print("冲啊。。。【%s】" % self.name)
        # 3让枪装填子弹
        self.gun.add_bullet(50)
        # 4让枪发射子弹
        self.gun.shoot()

#1.创建枪对象
ak47 = Gun("AK47")
# ak47.add_bullet(50)
# ak47.shoot()
#2创建许三多对象
xusanduo = Soldier('许三多')
#用赋值语句，将枪赋值给许三多枪的属性
xusanduo.gun = ak47
#调用开火方法
xusanduo.fire()
# print(xusanduo.gun)

身份运算符

私有属性和私有方法

class Women:
    def __init__(self,name):
        self.name = name
        #属性名前加__变为私有属性
        self.__age  = 18
    def __secret(self):
        #在对象的方法内部，是可以访问私有属性
        print("%s的年龄是%d"%(self.name,self.__age))

xiaofang = Women('小芳')
#私有属性在外界不能访问
# print(xiaofang.__age)
#私有方法不能在外界调用
# xiaofang.__secret()

伪私有属性和方法

xiaofang = Women('小芳')
#私有属性在外界不能访问
print(xiaofang._Women__age)
#私有方法不能在外界调用
xiaofang._Women__secret()

强行调用：_类名__私有名称

2、继承

class 类名（父类名）：

​ pass

class Animal:
    def eat(self):
        print('吃')
    def  drink(self):
        print('喝')
    def run(self):
        print('跑')
    def sleep(self):
        print('睡')


#狗类继承父类的属性和方法
class Dog(Animal):
    def bark(self):
        print('吠')
#创建狗对象
wangcai = Dog()
wangcai.eat()
wangcai.drink()
wangcai.run()
wangcai.sleep()
wangcai.bark()

方法的重写

class Dog(Animal):
    def bark(self):
        print('吠')


class Xiaotianquan(Dog):
    def fly(self):
        print('我会飞！')
    #覆盖父类的方法
    def bark(self):
       print('叫的跟神一样。。。')

 def bark(self):
        #1针对子类的特有需求，编写代码
        print('叫的跟神一样。。。')
        #2.使用super().父类方法名,调用原本在父类中封装的方法
        super().bark()
        #3.增加其他子类代码
        print('!@#$%&')

 #使用父类名.方法名（self）
        Dog.bark(self)

子类能否访问父类的私有属性方法

#1.在子类的对象方法中，不能直接访问父类的私有属性
#2.在子类的对象方法中，不能直接调用父类的私有方法

但是可以在父类的共有方法中，直接写调用私有属性和方法的代码，子类再直接访问父类的

多继承

class A:
    def test(self):
        print("test方法")


class B:
    def demo(self):
        print("demo方法")


class C(A,B):
    #多继承可以让子类对象，同时具有多个父类的属性和方法
    pass

#创建c子类对象
c = C()
c.test()
c.demo()

子类先继承那个父类，优先调用该父类重名的方法

3、多态

两个前提：1、有继承；2、重写父类方法

多态案例演练

class Dog(object):
    def __init__(self,name):
        self.name = name

    def game(self):
        print("%s蹦蹦跳跳的玩耍。。"%self.name)


class Xiaotianquan(Dog):
    def game(self):
        print('%s飞到天上去玩耍。。。'% self.name)



class Person(object):
    def __init__(self,name):
        self.name = name

    def game_with_dog(self,dog):
        print('%s 和 %s快乐的玩耍'%(self.name,dog.name))
        #让狗玩耍
        dog.game()


#1.创建一个狗对象
wangcai = Dog('旺财')
#创建Dog的子类对象
wangcai = Xiaotianquan('旺财')
#2.创建一个小明人对象
xiaoming = Person('小明')
#3.让小明调用和狗玩的方法
xiaoming.game_with_dog(wangcai)

术语

每一个对象都有自己独立的内存空间，保存各自不同的属性

多个对象的方法，在内存中只有一份

类是一个特殊的对象

class Tool(object):
    #使用赋值语句定义类属性，记录所有工具对象的数量
    count = 0
    def __init__(self,name):
        self.name = name
    #让类属性的值加+1
        Tool.count += 1

#1创建工具的对象
tool1 = Tool('斧头')
tool2 = Tool('榔头')
tool3 = Tool('榔头')
#2输出工具对象的总数
print(Tool.count)

使用赋值语句定义类属性，记录所有工具对象的数量

调用：类名。属性名 = 值

推荐使用类名.属性来获得类属性

定义类方法

class Tool(object):
    #使用赋值语句定义类属性，记录所有工具对象的数量
    count = 0
    #定义类方法
    @classmethod
    def show_tool_count(cls):
        print("工具对象的数量%d"% cls.count)

用cls.属性名访问属性

静态方法

class Dog(object):
    #定义静态方法
    @staticmethod
    def run():
        print('小狗要跑。。。')

#调用静态方法，通过类名.方法名调用静态方法
#创建静态方法，不需要创建狗对象
Dog.run()

创建静态方法，不需要创建狗对象

不需要访问类属性和对象属性，就可以创建静态方法

综合案例演练

class Game(object):
    #定义类属性，历史最高分
    top_score = 0
    #实例属性，在初始化方法类定义
    def __init__(self,player_name):
        self.player_name = player_name
    #定义静态方法
    @staticmethod
    def show_help():
        print("帮助信息，让僵尸进入大门")

    #定义类方法
    @classmethod
    def show_top_score(cls):
        print("历史记录 %d"% cls.top_score)


    #定义普通实例方法
    def start_game(self):
        print("%s 开始游戏啦。。。"% self.player_name)

#1.查看游戏的帮助信息
Game.show_help()#调用静态方法
#2.查看历史最高分
Game.show_top_score()#调用类方法
#3.创建游戏对象
game = Game("小明")
game.start_game()

4、单例设计模式

new方法返回对象的引用，将引用作为一个参数，传递给init的self

单例案例

在类中创建对象，在系统中只有唯一的一个实例

class MusicPlayer(object):
    #定义一个类属性
    instance = None
    def __new__(cls, *args, **kwargs):
        #1.判断类属性是否是空对象，用is
        if cls.instance is None:
            #2.调用父类的方法，为第一个对象分配空间
            cls.instance = super().__new__(cls)
        #3.返回类属性保存的对象引用
        return cls.instance

#创建多个对象
player1 = MusicPlayer()
player2 = MusicPlayer()
print(player1,player2)

    def __init__(self):
        #1判断是否执行过初始化动作
        if MusicPlayer.init_flag is True:
            return
        #2如果没有执行，执行初始化动作
        print("初始化播放器")
        #3修改类属性的值
        MusicPlayer.init_flag = True

5、异常

捕获异常

try:
    #不能确定是否正常运行的代码，放在try关键字下方
    num = int(input("请输入一个整数："))

except:
    #放错误后运行的代码
    print("请输入正确的整数")
#无论是否正常运行，都会执行后面的代码
print("-" * 50)

针对错误类型捕获异常

try:
    #提示用户输入一个整数
    num  = int (input("输入一个整数："))

    #使用8除以用户输入的整数并且输出
    result = 8/ num

    print(result)
except ZeroDivisionError:
    print("除0错误")

except ValueError:
    print('请输入正确的整数')

捕获未知错误

except Exception as result:
    print("位置错误 %s"% result)

异常捕获的完整代码

except Exception as result:
    print("位置错误 %s"% result)

else:#没有错误，就执行else
    print("尝试成功")
finally:
    print('无论是否错误，都会执行的代码')
print('-'*50)

异常的传递

def demo1():
    return int(input('请输入整数：'))

def demo2():
    return demo1()

#利用异常的传递性，在主程序捕获异常
try:
    print(demo2())
except Exception as result:

    print('未知错误 %s' % result)

在主函数中加入异常模块

抛出raise异常

def input_password():
    #1.提示用户输入密码
    pwd = input("请输入密码：")
    #2.判断密码长度>=8
    if len(pwd) >= 8:
        return pwd
    #3.如果小于8，主动抛出异常
    print("主动抛出异常")
    #1>创建异常对象,可以使用错误信息字符串作为参数
    ex = Exception('密码长度不够')
    #2>主动抛出异常
    raise ex
#提示用户输入密码
try:
    print(input_password())
except Exception as result:
    print(result)

12模块

)]

标识符：以数字，字母，下划线组成，并且不能以数字开头

别名导入

from … .import导入

注意事项

后导入的函数会把之前导入的函数覆盖掉

通过as起别名，给其中一个工具起别名

from hm_02_模块2 import say_hello as module2

from …import *

希望一次性导入模块中所有工具

from 模块名 import *

导入模块的顺序

import random
print(random.__file__)#查看模块路径
rand = random.randint(0,10)
print(rand)

开发原则

导入文件时，文件中所有没有任何缩进的代码都会被执行一遍

模块可以提供全局变量，函数，类

#全局变量，函数，类；直接执行的代码不是向外界提供的工具
def say_hello():
    print('你好！')
#如果直接执行模块，得到的是__main__
if __name__   == '__main__' :
    print(__name__)

    # 文件被导入时，能直接执行的代码不需要被执行
    print('小明开发的模块')
    say_hello()

13、包

pip安装第三方模块

14、文件概念及文本文件

文件的基本操作

open函数，打开文件对象

read，write，close，三个方法是文件对象调用的

read方法读取文件

#1.打开文件
file = open('README.txt',encoding='UTF-8')
#读取中文在open加encoding=‘UTF-8’
#2.读写文件
text = file.read()
print(text)
#3.关闭文件
file.close()

指针开始的位置：第一次打开文件时，open

指针结束的位置：执行read方法后。

#2.读写文件
text = file.read()
print(text)

print('-' * 50)
#再次执行read，读取内容为空
text = file.read()
print(text)

再次执行read，读取内容为空

打开文件的方式

w:写入会覆盖原来内容

a:以追加方式，指针在最后，写入

r+:读写方式打开文件，指针在文件开头；文件不存在，异常

w+:读写方式，会覆盖原来；创建文件

a+:读写方式，指针在末尾；创建文件

开发中更多以W,R为主

按行读取文件内容

文件复制

#1.打开文件，复制和写入
file_read = open('README.txt')
file_write = open('README[复制]','w')
#2.读写操作
while True:
    #读取一行内容
    text = file_read.readline()
    # 判断是否读取到内容
    if not text:
        break
    file_write.write(text)
#3.关闭文件，两个
file_read.close()
file_write.close()

文件、目录常用的管理操作

eval函数

input_str = input('请输入算术题:')
print(eval(input_str))
#1+1=2

1 eval函数的简介和语法：

eval()函数用来执行一个字符串表达式，并返回表达式的值。还可以把字符串转化为list、tuple、dict。

eval函数的语法：

eval(expression[,globals[,locals]])

参数：

expression：表达式。

globals：变量作用域，如果被提供，必须是一个字典对象。

locals：变量作用域，如果被提供，可以说任何映射对象。

2 eval()函数使用实例：
1 字符串转换成列表：
a="[1,2,3,4,5]"
b=eval(a)

a是字符串类型数据，b是列表类型数据

2 字符串转换成字典 ：
a="{"name":"guo","age":25}"
b=eval(a)

a为字符串类型数据，b为字典类型数据

3 字符串转换为元组：
a="(1,2,3,4,5)"
eval(a)

a的数据结构是字符串 b的数据结构是元组

————————————————
例子链接：https://blog.csdn.net/quanlingtu1272/article/details/95454722

16、VI简介–终端编辑器

打开和新建文件

map函数

map是python内置函数，会根据提供的函数对指定的序列做映射。

map()函数的格式是：

map(function,iterable,…)
1、第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。

把函数依次作用在list中的每一个元素上，得到一个新的list并返回。注意，map不改变原list，而是返回一个新list。

del square(x):
    return x ** 2
map(square,[1,2,3,4,5])
# 结果如下:
[1,4,9,16,25]

通过使用lambda匿名函数的方法使用map()函数：

map(lambda x, y: x+y,[1,3,5,7,9],[2,4,6,8,10])

# 结果如下：
[3,7,11,15,19]

当不传入function时，map()就等同于zip()，将多个列表相同位置的元素归并到一个元组：

map(None,[2,4,6],[3,2,1])

# 结果如下
[(2,3),(4,2),(6,1)]

将元组转换为list：

map(int,(1,2,3))

# 结果如下：
[1,2,3]

将字符串转换为list：

map(int,'1234')

# 结果如下：
[1,2,3,4]

提取字典中的key，并将结果放在一个list中：

map(int,{1:2,2:3,3:4})

# 结果如下
[1,2,3]

zip函数

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]

>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
>>>

filter函数

filter()也是Python常用的内置函数，用于过滤序列。与map()类似，filter()也是接收两个参数：一个函数和一个序列，将函数作用在序列的每一个元素上，根据函数返回值True或False，来决定是否舍弃该元素，最终返回一个迭代器，内容是原序列的子序列。例如：

def is_even(x):
    return x % 2 == 0
l = filter(is_even,[0,1,2,3,4,5])
print(l)
for var in l:   #for循环遍历迭代器l
    print(var)
    
#结果
<filter object at 0x7f14037fcc50>
0
2
4

例1：给定一个字符串元组，筛选出包含python的所有字符串。

str_tuple = ("hipython","pyth","lovepython","PYTHON","XMU")
result = filter((lambda x:x.find("python")!=-1), str_tuple)
for str in result:
    print(str)
    
#结果
hipython
lovepython

eval函数

eval() 函数用来执行一个字符串表达式，并返回表达式的值。

eval(expression[, globals[, locals]])

expression – 表达式。
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals–变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值：返回表达式计算结果。

使用eval()函数，将字符串还原为数字类型，和int()函数的作用类似

# 表达式
s1 = '3*7'
s2 = 'pow(2,3)'
n = eval(s1)
m = eval(s2)
print(n, m)
#结果
21 8

对表达式的结果进行计算，返回计算后的值

mX-1661998025652)]

[外链图片转存中…(img-Kol9KMbO-1661998025654)]

打开和新建文件

[外链图片转存中…(img-PEqAqRyw-1661998025655)]

map函数

map是python内置函数，会根据提供的函数对指定的序列做映射。

map()函数的格式是：

map(function,iterable,…)
1、第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个集合。

把函数依次作用在list中的每一个元素上，得到一个新的list并返回。注意，map不改变原list，而是返回一个新list。

del square(x):
    return x ** 2
map(square,[1,2,3,4,5])
# 结果如下:
[1,4,9,16,25]

通过使用lambda匿名函数的方法使用map()函数：

map(lambda x, y: x+y,[1,3,5,7,9],[2,4,6,8,10])

# 结果如下：
[3,7,11,15,19]

当不传入function时，map()就等同于zip()，将多个列表相同位置的元素归并到一个元组：

map(None,[2,4,6],[3,2,1])

# 结果如下
[(2,3),(4,2),(6,1)]

将元组转换为list：

map(int,(1,2,3))

# 结果如下：
[1,2,3]

将字符串转换为list：

map(int,'1234')

# 结果如下：
[1,2,3,4]

提取字典中的key，并将结果放在一个list中：

map(int,{1:2,2:3,3:4})

# 结果如下
[1,2,3]

zip函数

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一个对象
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 转换为列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]

>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
>>>

filter函数

filter()也是Python常用的内置函数，用于过滤序列。与map()类似，filter()也是接收两个参数：一个函数和一个序列，将函数作用在序列的每一个元素上，根据函数返回值True或False，来决定是否舍弃该元素，最终返回一个迭代器，内容是原序列的子序列。例如：

def is_even(x):
    return x % 2 == 0
l = filter(is_even,[0,1,2,3,4,5])
print(l)
for var in l:   #for循环遍历迭代器l
    print(var)
    
#结果
<filter object at 0x7f14037fcc50>
0
2
4

例1：给定一个字符串元组，筛选出包含python的所有字符串。

str_tuple = ("hipython","pyth","lovepython","PYTHON","XMU")
result = filter((lambda x:x.find("python")!=-1), str_tuple)
for str in result:
    print(str)
    
#结果
hipython
lovepython

eval函数

eval() 函数用来执行一个字符串表达式，并返回表达式的值。

eval(expression[, globals[, locals]])

expression – 表达式。
globals – 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals–变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
返回值：返回表达式计算结果。

使用eval()函数，将字符串还原为数字类型，和int()函数的作用类似

# 表达式
s1 = '3*7'
s2 = 'pow(2,3)'
n = eval(s1)
m = eval(s2)
print(n, m)
#结果
21 8

对表达式的结果进行计算，返回计算后的值