Python

1.1解释器

编译器翻译的方式有2种方式：编译、解释。

区别在于翻译时间点的不同。当编译器以解释方式运行的时候，也称为解释器。

   











      

CPU

      

操作系统     Windows/linux/Mac

         

编译器

      

最终可执行文件

        

解释器     运行解释每一句源代码

      

解释型语言           源代码

      

编译型语言           源代码

  编译型语言和解释型语言对比
速度- -编译型语言比解释型语言执行速度快
跨平台性- -解释型语言比编译型语言跨平台性好
github  let code

1.2 Python 特点
Python是完全面向对象的语言
  Python拥有一个强大的标准库
  Python社区提供了大量的第三方模块
1.3Python优缺点
  优点：简单、易学、免费、开源、面向对象、丰富库、可扩展性。

缺点：运行速度、市场较小。

1.4 Python编写错误

1.手误：名称错误

2.将多条写在一行：语法错误

3.缩进错误:不期望出现的缩进

4.python2.x默认不支持中文

Python2.x的解释器名称Python

Python3.x的解释器名称python3

第一个程序

   # Desktop切到桌面             cd Desktop

# mkdir创建文件夹             mkdir 认识python

# cd进入文件夹                cd 认识python

# touch创建一个.py            touch 第一个程序.py

# gedit 编辑文档           gedit 01-第一个程序.py   

# print(“hello”)

# 运行python加执行文件    ctrl+s保存  python3 运行   

1.5 Python的IDE- -PyCharm

  集成开发环境(IDE)

   1.图形用户界面

  2.代码编辑器（支持代码补全、自动缩进）

  3.编译器/解释器

  4.调试器（断点/单步执行）   

1.6 PyCharm  新建项目

  Windows 下的PyCharm

1.桌面新建一个文件夹名为01_python基础

2.打开PyCharm 找到Open 选择桌面文件夹目录C:\Users\Administrator\Desktop\01_python基础

  3.创建.py文件

                      File          new           python file (名为hm_01_hello)

编辑: print(“hello python”)

     Print(“你好世界”)

发现运行不了file          settings          project:01下的interpreter下拉选择确定然后运行。

1.7注释

单行注释：以#开头，#右边所有东西都被当做说明文字，而不是真正要执行的程序，只起到辅助说明作用。 为了保证代码的可读性，# 后面建议先添加一个空格，然后再编写相应的说明文字。

但是，需要注意的是，为了保证代码的可读性，注释和代码之间至少要有两个空格。

多行注释：要在 Python 程序中使用多行注释，可以用 一对 连续的 三个 引号(单引号和双引号都可以)

1.8变量定义

   1.在Python中，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。等号（=）用来给变量赋值。

例：qq_number =”1234567”               price=8.5

qq_password= ”123”                 weight=7.5

Print(qq_number)                     money=price*weightr

Print(qq_password)                   money=money-5

                                     Print(money)

   2.变量的类型

     变量的名称              变量保存的数据

变量存储数据的类型      变量的地址

   3.数据类型：字符串（str） 布尔（真假）bool

     整数（int） float(浮点数)

1.9不同类型变量之间的计算

     定义整数int=10

     定义浮点数float=10.5

     定义布尔型bool=True

(1)字符串变量之间使用+拼接生成新的字符串

(2)字符串变量可以和整数使用*重复拼接相同的字符串

(3)数字型变量和字符串之间不能进行其他计算

  2.0变量的输入

   （1）关于函数

   Print(x) 将x输出到控制台

   type(x) 查看x的变量类型

   （2）input函数实现键盘输入

   在Python中可以使用input函数从键盘等待用户名的输入

   用户输入的任何Python都认为是一个字符串

   （3）类型转换函数

   Int(x) 将x转换为一个整数

   Float(x) 将x转换到一个浮点数

例：price=float(input("苹果的价格"))
   weight=float(input("苹果的重量"))
   money=price*weight
   print(money)

2.1变量的格式化输出

%S          字符串

%d          有符号十进制整数，%06d表示输出整数显示位数，不足使用补充0  

%f          浮点数，%.2f表示小数点后只显示俩位

%%          输出%               

2.2标识符关键字

  1.标识符：

  （1）标识符可以由字母、下划线和数字组成

  （2）不能以数字开头

  （3）不能与关键字重名

  2.关键字

  （1）关键字就是在python内部已使用的标识符

  （2）关键字具有特殊的功能和含义

  （3）开发着不允许定义和关键字相同的名字的标示符

  3.工具包

  （1）import关键字可以导入一个工具包

  （2）在python中不同的工具包，提供有不同的工具

  4.变量的命名规则

注意：python中的标识符是区分大小写的

  （1）在定义变量时，为了保证代码格式式，=的左右应该各保留一个空格

  （2）在python中，如果变量名需要由二个或多个单词组成时，可以按照以下方式命名

    a.每个单词都使用小写字母

    b.单词与单词之间使用_下划线连接

  5.驼峰命名法

    1.小驼峰式命名法：第一个单词以小写字母开始，后续单词的首字母大写

    2.大驼峰式命名法：每一个单词的首字都采用大写字母

2.3判断（if）语句

1.if判断语句基本语法

  在python中，if语句就是用来进行判断的

注意：代码的缩进为一个tab键，或者4个空格—建议使用空格，Tab和空格不要混用

2.判断年龄

需求                                    age=int(input("请输入年龄"))

1输入用户年龄                          ifage>=18:      

2.判断是否满 18 岁 （>=）                 print("允许进入网吧")

3.如果满 18 岁，允许进网吧嗨皮          else:

  4..如果未满 18 岁，提示回家写作业         print("回家写作业")   

3．逻辑运算

1．  and   

  (1)与/并且

（2）同真得真，一假得假

2.   or

（1） 或/或者

（2）一真得真，全假得假

3.   not   

  非/不是

例：

1.判断年龄是否正确要求在0-120之间

age=int(input("请输入年龄"))
if age>=0 and age<=120:
     print("ok")
else:
     print("ON")

3. 定义一个布尔型变量 is_employee，编写代码判断是否是本公司员工

如果不是提示不允许入内

is_employee=True
if notis_employee:
     print("不允许入内")

     

2. 定义两个整数变量 python_score、c_score，编写代码判断成绩（要求只要有一门成绩 > 60 分就算合格）

python_score=50
  c_score=50
  ifpython_score > 60 or c_score > 60:
     print("合格")
else:

print("不合格")

4.if语句进阶

Lelif

(1)在开发中，使用if可以判断条件

（2）使用else可以处理条件不成立的情况

注意：1.elif和else都必须和if联合使用，而不能单独使用。

2.可以将if、elif和else以及各自缩进的代码，看成一个完整代码块

例：

   女友的节日

需求

1.定义 holiday_name 字符串变量记录节日名称

2.如果是 情人节 应该 买玫瑰／看电影

3.如果是 平安夜 应该 买苹果／吃大餐

4.如果是 生日 应该 买蛋糕

5.其他的日子每天都是节日啊……

   holiday_name="平安夜"
if holiday_name=="情人节":
    print("买玫瑰")
    print("看电影")
elif holiday_name=="平安夜":
    print("买苹果")
    print("吃大餐")
elif holiday_name=="生日":
    print("买蛋糕")
else:
    print("每天都是节日")

   5.if的嵌套

1.在开发中，使用if进行条件判断，如果希望在条件成立的执行语句中再增加条件判断，就可以使用if的嵌套

2.if的嵌套的应用场景就是，在之前条件满足的前提下，再增加额外的判断

3.if的嵌套的语法格式式，除了缩进之外和之前的没有区别

例：火车站安检

需求

1.  定义布尔型变量 has_ticket 表示是否有车票

2.  定义整型变量 knife_length 表示刀的长度，单位：厘米

3.  首先检查是否有车票，如果有，才允许进行 安检

4.  安检时，需要检查刀的长度，判断是否超过 20厘米

（1）如果超过 20 厘米，提示刀的长度，不允许上车

（2）如果不超过 20 厘米，安检通过

5.  如果没有车票，不允许进门

has_ticket = True
knife_length = 30
if has_ticket:
     print("车票检查通过，准备开始安检")
     if knife_length > 20:
         print("安检不通过,有%d公分长"%knife_length)
         print("不允许上车")
     else:
         print("安检已通过")
else:
     print("大哥先买票")

6.综合应用——剪刀石头布

例：

需求

1．从控制台输入要出的拳 —— 石头（1）／剪刀（2）／布（3）

2．电脑 随机 出拳 —— 先假定电脑只会出石头，完成整体代码功能

3.比较胜负

import random
player = int(input("输入要出的拳 —— 石头（1）／剪刀（2）／布（3）"))
computer = random.randint(1,3)
print("玩家选择的 %d - 电脑出的是 %d" %(player,computer))
if ((player==1 and computer==2)
        or (player==2 and computer==3)
        or (player==3 and computer==1)):

    print("欧耶，电脑弱爆了")
elif (player==computer):
    print("真是心有灵犀")
else:
    print("不要走，我们决战到天亮")

2.4循环

  1.顺序：从上向下，顺序执行代码。

  2.分支：根据条件判断。决定执行代码的分支

  3.循环：让特定代码重复执行

2.5 while语句基本语法

注意：while语句以及缩进部分是一个完整的代码块

例：第一个 while 循环需求打印 5 遍 Hello Python

i = 1

while i <= 5:

    print("Hello Python")

    i = i + 1

print("循环结束后的 i = %d" %i)

注意：循环结束后，之前定义的计数器条件的数值是依旧存在的

死循环：由于程序员的原因，忘记 在循环内部 修改循环的判断条件，导致循环持续执行，程序无法终止！

  2.6赋值运算符

1. 在 Python 中，使用 = 可以给变量赋值。

2. 在算术运算时，为了简化代码的编写，Python 还提供了一系列的与算术运算符对应的赋值运算符。

注意：赋值运算符中间不能使用空格。

=   简单的赋值运算符          /=   除法赋值运算符

+=  加法赋值运算符            //=取整除赋值运算符

-=  减法赋值运算符            %=取模(余数)赋值运算符

*=  乘法赋值运算符             **=幂赋值运算符

2.7 python中的计数方法

1.自然计数法（从1开始）--更符合人类的习惯

2.程序计数法（从0开始）--几乎所有的程序语言都选择从0开始计数

3．    除非需求的特殊要求，否则 循环 的计数都从 0 开始

2.8循环计算

1.  在while上方定义一个变量，用于存放最终计算结果。

2.  在循环体内部，每次循环都用 最新的计算结果，更新 之前定义的变量

  例：计算 0 ~ 100 之间所有数字的累计求和结果

result = 0

i = 0

while i <= 100:

     print(i)

     result+= i

     i += 1

print("0~100之间的数字求和结果 = %d" % result)

2.9   break 和 continue

1.  break 某一条件满足时，退出循环，不再执行后续重复的代码。

2.  continue 某一条件满足时，不执行后续重复的代码。

3.0循环嵌套

例：九九乘法表  

1.用嵌套打印小星星                                                                             

需求在控制台连续输出五行 *，每一行星号的数量依次递增

  

row = 1

while row<= 5:

print("*"* row)

row += 1

2.在控制台连续输出五行 *，每一行星号的数量依次递增

i=1
while i<=5:
    row=1
    while row<=i:
        print("*",end=(""))
        row+=1
    print("")
    i+=1

3．需求 输出 九九乘法表

    row=1
while row <= 9:
    col=1
    while col<=row:
        print("%d*%d=%d" %(col,row,col*row),end=("\t"))
        col+=1
    print("")
    row+=1 3.1函数基础

函数的文档注释

1.在连续的三对引号之间编写函数说明文字。

2.在函数调用位置使用ctrl+Q可以查看函数的说明信息。

注意：因为函数体相对比较独立函数定义的上方，应该和其他代码（包括注释）保留 两个空行。

函数参数的使用

1.   在函数名的后面的小括号内部填写参数。

2.   多个参数之间使用 ，分隔。

参数的作用

1.   函数，把 具有独立功能的代码块 组织为一个小模块，在需要的时候 调用。

2.函数调用时，按照函数定义的参数顺序，把 希望在函数内部处理的数据，通过参数 传递。

  形参和实参

1. 形参：定义 函数时，小括号中的参数，是用来接收参数用的，在函数内部 作为变量使用。

2. 调用函数时，小括号中的参数，是用来把数据传递到函数内部用的。

函数的返回值

1. 返回值返回值是函数 完成工作后，最后给调用者的一个结果。

2. 在函数中使用return关键字可以返回结果。

3. 调用函数一方，可以使用变量来接收函数的返回结果。

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

3.2高级变量类型

   列表的定义

1.   List（列表）是python中使用最频繁的数据类型，在其他语言中通常叫数组。

2.   数据之间用，分隔。

3.   列表的索引从0开始。

注意：从列表中取值如果 超出索引范围，程序会报错。

                        列表操作

             查

1. Index  取值  取索引  

  增加 修改

2. append  列表末尾追加数据

insert  指定索引位置插入数据

extend  继承末尾添加多个  

               

                      删除

3.remove   列表中指定删除数据

   Pop     默认列表中最后一个元素删除（指定要删除元素的索引）有返回值

   Clear   整个列表清空

   del     删变量   

注意：如果使用del关键字将变量从内存中删除后续的代码就不能使用这个变量了。   

                 统计

4.len        统计列表中元素的总数（长度）

  Count      统计列表中某一个数据出现的次数

                 排序

5.sort( )            升序排序

  Sort(rebever=Ture)  降序排序

                        逆序（翻转）

Reverse( )           逆序、反转  

               

循环遍历

1. 遍历就是从头到尾依次从列表中获取数据。

2. 在python中提高列表的遍历效率，专门提供的迭代iteration遍历。

For name in name_list:

       循环内部针对列表元素进行操作

       Print(name)

                 元组

元组的定义

1．Tuple（元组）与列表类似，不同之处在于元组的元素不能修改。

2．元组表示多个元素组成的序列。

创建空元组

Info_tuple=( )

Info_tuple=（50，）

元组常用操作

Count、index

                   应用场景

1. 函数的参数和返回值，一个函数可以接收任意多个参数，或者一次返回多个数据。

2. 元组不可以被修改。

                 字典

          字典的定义

1. 是 除列表以外 Python 之中 最灵活 的数据类型字典同样可以用来存储多个数据。

2. 列表是有序的对象集合字典是无序的对象集合。

3. 字典用 {} 定义字典使用键值对存储数据，键值对之间使用 , 分隔 。

键key是索引

值value是数据

键和值之间使用:分隔

键必须是唯一的

值可以取任何数据类型，但键只能使用字符串、数字或元组

            循环遍历

           xiaoming={"name":"xiaoming",}for k in xiaoming:

                 Print(“%s:%s” %(k,xiaoming[k]))

           (1 )word符合

                        字符串

            字符串的定义

1．字符串就是一串字符，是编程语言中表示文本的数据类型

2．在 Python 中可以使用一对双引号 " 或者 一对单引号 ' 定义

一个字符串虽然可以使用 \" 或者 \' 做字符串的转义

字符串的常用操作

查找替换

string.startswith(str)	检查字符串是否是以 str 开头，是则返回 True
string.endswith(str)	检查字符串是否是以 str 结束，是则返回 True
string.find(str, start=0, end=len(string))	检测 str 是否包含在 string 中，如果  start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1
string.rfind(str, start=0, end=len(string))	类似于 find()，不过是从右边开始查找
string.index(str, start=0, end=len(string))	跟 find() 方法类似，不过如果 str 不在 string 会报错
string.rindex(str, start=0, end=len(string))	类似于 index()，不过是从右边开始
string.replace(old_str, new_str, num=string.count(old))	把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次

判断类型

string.isdecimal()	如果 string 只包含数字则返回 True，全角数字
string.isdigit()	如果 string 只包含数字则返回 True，全角数字、⑴、\u00b2
string.isnumeric()	如果 string 只包含数字则返回 True，全角数字，汉字数字
string.istitle()	如果 string 是标题化的(每个单词的首字母大写)则返回  True

拆分和连接

string.partition(str)	把字符串 string 分成一个 3 元素的元组 (str前面,  str, str后面)
string.rpartition(str)	类似于 partition() 方法，不过是从右边开始查找
string.split(str="", num)	以 str 为分隔符拆分 string，如果 num  有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 '\r', '\t', '\n' 和空格
string.splitlines()	按照行('\r', '\n', '\r\n')分隔，返回一个包含各行作为元素的列表
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串

                     字符串的切片

1. 切片方法适用于字符串、列表、元组。

2.切片使用索引值来限定范围，从一个大的字符串中切出小的字符串。

3.列表和元组都是有序的集合，都能够通过索引值获取到对应的数据。

4.字典是一个无序的集合，是使用键值对保存数据。

注意：

1.指定的区间属于左闭右开型 [开始索引, 结束索引) => 开始索引 >= 范围 < 结束索引从起始位开始，到结束位的前一位结束（不包含结束位本身)

1.  从头开始，开始索引数字可以省略，冒号不能省略。

2.  到末尾结束，结束索引数字可以省略，冒号不能省略。

3.  步长默认为1，如果连续切片，数字和冒号都可以省略。

例：

Num_str=”0123456789”

1.   截取从 2 ~ 5位置 的字符串

print(num_str[2:6])

2.   截取从 2~ 末尾 的字符串

print(num_str[2:]

3.   截取从 开始 ~ 5 位置的字符串

print(num_str[:6]

4.   截取完整的字符串

print(num_str[:])

5.   从开始位置，每隔一个字符截取字符串

print(num_str[::2])

6.   从索引 1 开始，每隔一个取一个

print(num_str[1::2])

7.   截取从 2~ 末尾 - 1 的字符串

print(num_str[2:-1])

8.   截取字符串末尾两个字符

print(num_str[-2:])

9.   字符串的逆序（面试题）

print(num_str[::-1])

                     变量进阶

变量的引用   

1.变量和数据是分开存储的。2.数据保存在内存中的一个位置。3.变量中保存着数据在内存中的地址。4.变量中记录数据的地址，就叫做引用。5.使用id()函数可以查看变量中保存数据所在的内存地址。注意：如果变量已经被定义，当给一个变量赋值的时候，本质上是修改了数据的引用。

变量不再对之前的数据引用

变量改为对新赋值的数据引用

   函数的参数和返回值的传递

在Python 中，函数的实参/返回值都是是靠引用来传递来的。                 可变和不可变类型

不可变类型，内存中的数据不允许被修改：

1．     数字类型 int, bool, float, complex, long(2.x)

2．     字符串 str

3．     元组 tuple

可变类型，内存中的数据可以被修改：

1. 列表 list

2. 字典 dict

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

       1.可变类型的数据变化，是通过方法 来实现的。

      2.如果给一个可变类型的变量，赋值了一个新的数据，引用会修改。

      3.变量不再对之前的数据引用。

      4.变量改为对新赋值的数据引用。

                          哈希 (hash)

python 中内置有一个名字叫做 hash(o) 的函数

1.接收一个不可变类型 的数据作为 参数。

2.返回结果是一个整数。

哈希是一种算法，其作用就是提取数据的特征码（指纹）

1.相同的内容得到相同的结果。

2.不同的内容得到不同的结果。

在 Python中，设置字典的键值对 时，会首先对 key 进行 hash 已决定如何在内存中保存字典的数据，以方便后续对字典的操作：增、删、改、查。

1.键值对的 key 必须是不可变类型数据

2.键值对的 value 可以是任意类型的数据

                       局部变量和全局变量

1.局部变量是在 函数内部 定义的变量，只能在函数内部使用。

2.全局变量是在 函数外部定义的变量（没有定义在某一个函数内），所有函数内部都可以使用这个变量。

                             局部变量

1.局部变量是在函数内部定义的变量，只能在函数内部使用。

2.函数执行结束后，函数内部的局部变量，会被系统回收。

3.不同的函数，可以定义相同的名字的局部变量，但是彼此之间不会产生影响。

     局部变量的作用：在函数内部使用，临时 保存 函数内部需要使用的数据。

                            局部变量的生命周期

1.所谓生命周期就是变量从被创建到被系统回收的过程。

2．局部变量在函数执行时才会被创建。

3．函数执行结束后局部变量被系统回收。

4.局部变量在生命周期 内，可以用来存储 函数内部临时使用到的数据。

                              全局变量

     全局变量:是在函数外部定义的变量，所有函数内部都可以使用这个变量。

注意：函数执行时，需要处理变量时会：

1.   首先 查找 函数内部 是否存在 指定名称的局部变量，如果有，直接使用。

2.   如果没有，查找函数外部 是否存在 指定名称 的全局变量，如果有，直接使用

3.   如果还没有，程序报错！

注意：只是在函数内部定义了一个局部变量而已，只是变量名相同 —— 在函数内部不能直接修改全局变量的值。

1.在函数内部修改全局变量的值：

如果在函数中需要修改全局变量，需要使用 global 进行声明。

2. 全局变量定义的位置：

为了保证所有的函数都能够正确使用到全局变量，应该 将全局变量定义在其他函数的上方。

                    函数参数和返回值的作用

函数根据 有没有参数 以及 有没有返回值，可以 相互组合，一共有 4 种 组合形式

无参数，无返回值                    无参数，有返回值

有参数，无返回值                    有参数，有返回值

1.   如果函数 内部处理的数据不确定，就可以将外界的数据以参数传递到函数内部。

2.   如果希望一个函数 执行完成后，向外界汇报执行结果，就可以增加函数的返回值。

                              函数的返回值进阶

1.返回值是函数完成工作后，最后 给调用者的一个结果。

2.在函数中使用 return 关键字可以返回结果。

3．调用函数一方，可以使用变量来接收函数的返回结果。

                            交换两个数字

题目要求

1.   有两个整数变量 a = 6, b = 100

2.   不使用其他变量，交换两个变量的值

a,b=b,a
print(a)
print(b)

                                   函数的参数进阶

无论传递的参数是 可变 还是 不可变，只要 针对参数 使用 赋值语句，会在 函数内部 修改 局部变量的引用，不会影响到外部变量的引用。

如果传递的参数是 可变类型，在函数内部，使用 方法 修改了数据的内容，同样会影响到外部的数据。

                               缺省参数

1.定义函数时，可以给某个参数指定一个默认值，具有默认值的参数就叫做缺省参数。

2.调用函数时，如果没有传入缺省参数 的值，则在函数内部使用定义函数时指定的 参数默认值。 外界传递！

缺省参数的注意事项缺省参数的定义位置：必须保证 带有默认值的缺省参数 在参数列表末尾。                               多值参数定义支持多值参数的函数

有时可能需要 一个函数 能够处理的参数 个数 是不确定的，这个时候，就可以使用 多值参数。

python 中有 两种 多值参数：

1.参数名前增加 一个 * 可以接收 元组。

2.参数名前增加 两个 * 可以接收 字典。

                          元组和字典的拆包

在调用带有多值参数的函数时，如果希望：

将一个 元组变量，直接传递给 args

将一个 字典变量，直接传递给 kwargs

就可以使用 拆包，简化参数的传递，拆包 的方式是：

在 元组变量前，增加 一个 *。在 字典变量前，增加 两个 *。

                             函数的递归递归函数的特点

特点：

一个函数内部调用自己

函数内部可以调用其他函数，当然在函数内部也可以调用自。

代码特点

1.函数内部的代码 是相同的，只是针对参数不同，处理的结果不同。

2.当参数满足一个条件 时，函数不再执行。这个非常重要，通常被称为递归的出口，否则会出现死循环！

                     面向对象(OOP)基本概念一、面向对象基本概念

1．我们之前学习的编程方式就是 面向过程的。

2.面相过程 和 面相对象，是两种不同的编程方式。

3.对比 面向过程 的特点，可以更好地了解什么是面向对象。

二、过程和函数（科普）

1.过程是早期的一个编程概念。

2.过程类似于函数，只能执行，但是没有返回值。

3.函数不仅能执行，还可以返回结果。

三、面相过程 和 面相对象 基本概念

1.面相过程 —— 怎么做？

2.把完成某一个需求的所有步骤从头到尾逐步实现.。

3.根据开发需求，将某些功能独立的代码封装 成一个又一个 函数。

4.最后完成的代码，就是顺序地调用不同的函数。

特点

1. 注重步骤与过程，不注重职责分工

2. 如果需求复杂，代码会变得很复杂

3. 开发复杂项目，没有固定的套路，开发难度很大！

                                    类和对象

一、类和对象的概念

类和对象是面向对象编程的两个核心概念

二、类

1.类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用。

  - 特征被称为属性

  - 行为被称为方法

2.类就相当于制造飞机时的图纸，是一个模板，是负责创建对象的。

三、对象

1.对象是由类创建出来的一个具体存在，可以直接使用。

2.由哪一个类创建出来的对象，就拥有在哪一个类中定义的：

  - 属性                   - 方法

3.对象就相当于用图纸制造的飞机。

属性和方法的确定

1.对 对象的特征描述，通常可以定义成属性。

2.对象具有的行为（动词），通常可以定义成方法。

                            面相对象基础语法使用 self 在方法内部- 在类封装的方法内部，self 就表示 当前调用方法的对象自己- 调用方法时，程序员不需要传递 self 参数- 在方法内部  - 可以通过 self. 访问对象的属性  - 也可以通过 self. 调用其他的对象方法 初始化方法当使用类名() 创建对象时，会自动执行以下操作：  1. 为对象在内存中 分配空间 —— 创建对象  2. 为对象的属性 设置初始值 —— 初始化方法(init)这个初始化方法 就是 __init__ 方法，__init__ 是对象的内置方法 内置方法和属性__del__对象被从内存中销毁前，会被自动调用。 __str__返回对象的描述信息，print 函数输出使用。

_del__ 方法：

在Python中  1.当使用类名()创建对象时，为对象 分配完空间后，自动 调用 __init__ 方法。  2.当一个 对象被从内存中销毁 前，会 自动 调用 __del__ 方法应用场景 __init__ 改造初始化方法，可以让创建对象更加灵活 __del__ 如果希望在对象被销毁前，再做一些事情，可以考虑一下。_del__ 方法 生命周期  1.一个对象从调用 类名() 创建，生命周期开始。  2.一个对象的 __del__ 方法一旦被调用，生命周期结束。  3.在对象的生命周期内，可以访问对象属性，或者让对象调用方法。 __str__ 方法 在 Python中，使用 print 输出 对象变量，默认情况下，会输出这个变量 引用的对象 是 由哪一个类创建的对象，以及在内存中的地址（十六进制表示）  如果在开发中，希望使用 print 输出对象变量时，能够打印自定义的内容，就可以利用 __str__ 这个内置方法了。注意：__str__ 方法必须返回一个字符串。

                                                                  

面向对象封装封装

1.   封装 是面向对象编程的一大特点。

2.   面向对象编程的 第一步 —— 将属性和方法 封装到一个抽象的 类中。

3.   外界 使用 类 创建 对象，然后让对象调用方法。

4.   对象方法的细节都被封装 在类的内部。

提示：1.在对象的方法内部，是可以直接访问对象的属性的。

2.同一个类 创建的多个对象之间，属性互不干扰。

在定义属性时，如果 不知道设置什么初始值，可以设置为 None。

is是判断两个标识符是不是引用同一个对象 xis y，类似 id(x) == id(y)

isnot is not 是判断两个标识符是不是引用不同对象 xis not y，类似 id(a) != id(b)

is 与 == 区别：

is用于判断 两个变量 引用对象是否为同一个
== 用于判断 引用变量的值 是否相等

私有属性和私有方法

1.私有属性 就是 对象 不希望公开的 属性。

2.私有方法 就是 对象 不希望公开的 方法。

在 定义属性或方法时，在属性名或者方法名前 增加两个下划线，定义的就是私有属性或方法。

继承

·        单继承

·        多继承

子类拥有父类的所有方法和属性

方法的重写

当 父类的方法实现不能满足子类需求时，可以对方法进行重写。

重写 父类方法有两种情况：

1.    覆盖父类的方法。

2.    对父类方法进行 扩展。

覆盖父类的方法

如果在开发中，父类的方法实现 和 子类的方法实现，完全不同

就可以使用 覆盖 的方式，在子类中 重新编写 父类的方法实现   

Super: 在 Python 中 super 是一个 特殊的类super() 就是使用 super 类创建出来的对象最常 使用的场景就是在 重写父类方法时，调用 在父类中封装的方法实现。

多继承

子类可以拥有 多个父类，并且具有 所有父类 的属性 和方法。

object 是 Python 为所有对象提供的 基类，提供有一些内置的属性和方法，可以使用 dir 函数查看。