Python基础（II）

1.公共方法

1.1Python内置函数

Python包含了以下内置函数：

注意：字符串比较符合以下规则：“0”<“A”<“a”

1.2切片

切片使用索引值来限定范围，从一个大的字符串中切出小的字符串。
列表和元组都是有序的集合，都能够通过索引值获取到对应的数据。
字典是一个无序的集合，是使用键值对保存数据。(字典不能进行切片)

1.3运算符

注意：in在对字典操作时，判断的是字典的键。
in和not in 被称为成员运算符。
成员运算符：用于测试序列中是否包含指定的成员。

1.4完整的for循环语法

在Python中完整的for循环的语法如下：

for 变量 in 集合：
	循环体代码
else：
	没有通过break退出循环，循环结束后，会执行的代码

应用场景：
在迭代遍历嵌套的数据类型时，例如一个判断包含了多少个字典。

答案：student = [
    {
   "name": "小美"},
    {
   "name": "阿土"}
]
# 在學員列表中搜索指定的姓名
find_name = "阿土"
for stu in student:
    print(stu)
    if stu["name"] == find_name:
        print("找到了 %s" % find_name)
        break
else:
    print("sorry,NOt find")
print("循環結束")

2.变量进阶（理解）

1.变量的引用

变量和数据都是保存在内存中的。
在Python中函数的参数传递以及返回值都是靠引用传递的

1.1引用的概念

在python中：

• 变量和数据是分开存储的。
• 数据保存在内存中的一个位置。
• 变量中保存着数据在内存的地址。
• 变量中记录数据的地址，叫做引用。
• 使用id[]函数可以查看变量中保存所在的内存地址。

注意：如果变量已经被定义，当给一个变量赋值的时候，本质上是修改了数据的引用。

• 变量不再对之前的数据引用。
• 变量改为对新赋值的数据引用。
  

1.2变量引用的示例

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

在Python中，函数的实例/返回值 都是靠引用来传递的。

def test(num):
    print(" %d----- %d" % (num, id(num)))
    result = "hello"
    print("函数要返回数据的内存地址是%d" % id(result))
    return result
# 1.定义一个数字的变量
a = 10
# 数据的地址本质上就是一个数字 
print("a变量保存数据的内存地址是%d" % id(a))
# 2.调用test函数，本质上传递的是实参保存数据的引用，而不是实参保存的数据
# 注意：如果函数有返回值，但是没有定义变量接收
# 程序不会报错，但无法获得 返回结果
r = test(a)
print("%s内存地址是 %d" % (r, id(r)))

执行结果：
a变量保存数据的内存地址是10911424
 10----- 10911424
函数要返回数据的内存地址是140466029106880
hello内存地址是 140466029106880

2.可变和不可变类型

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

• 数字类型int、bool、float、complex、long(2.x)
• 字符串str
• 元组tuple
  可变类型，内存中的数据可以被修改：
• 列表：list
• 字典：dict
  注意：字典的key只能使用不可变类型的数据（数字、字符串、元组），不可是列表和字典。

注意：
①可变类型的数据变化，是通过反复来实现的。
②如果给一个可变类型的变量，赋值了一个新的数据，引用会修改。

• 变量不再对之前的数据引用
• 变量改为对新赋值的数据引用
  哈希（hash）
  ①Python中内置有一个名字叫做hash(o)的函数。
• 接收一个不可变类型的数据作为参数
• 返回结果是一个整数
  ②哈希是一种算法，其作用就是提取数据的特征码（指纹）
• 相同的内容得到相同的结果。
• 不同的内容得到不同的结果。
  ③在Python中，设置字典的键值对时，会首先对key进行hash已决定如何在内存中保存字典的数据，以方便后续对字典的操作：增删改查
• 键值对的key必须是不可变类型数据。
• 键值对的value可以是任意类型的数据。

3.局部变量和全局变量

3.1局部变量

• 局部变量是在函数内部定义的变量，**只能在函数内部使用。
• ** 函数执行结束后，**函数内部的局部变量，会被系统回收。
• ** 不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响。
  局部变量的作用：
  在函数内部使用，临时保存函数内部需要使用的数据。

def demo1():
    # 定义一个局部变量
    # 1.出生，执行了下方的代码之后，才会被创建
    # 2.死亡，函数执行完成之后
    num = 10
    print("在demo1函数内部的变量是%d" % num)


def demo2():
    num=99
    print("在demo2函数内部的变量是%d"% num)
    pass


# 在函数内部定义的变量，不能在其他位置使用

demo1()
demo2()
运行结果：
在demo1函数内部的变量是10
在demo2函数内部的变量是99

局部变量的生命周期：

• 所谓生命周期就是变量从被创建到被系统回收的过程。
• 局部变量在函数执行时才会被创建。
• 函数执行结束后局部变量被系统回收。
• 局部变量在生命周期内，可以用来存储函数内部临时使用到的数据。

3.2全局变量

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

# 全部变量
num = 10
def demo1():
    print("在demo1函数内部的变量是%d" % num)
def demo2():
    print("在demo2函数内部的变量是%d" % num)
demo1()
demo2()

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

1. 首先查找函数内部是否存在指定名称的全局变量，如果有，直接使用。
2. 如果没有，查找函数外部是否存在指定名称的全局变量，如果有，直接使用。
3. 如果还没有，程序报错。

1）函数不能直接修改全局变量的引用
全部变量是在函数外部定义的变量（没有定义在某一个函数内），所有函数内部都可以使用这个变量。
提示：在其他语言中大多不推荐使用全局变量–可变范围太大，导致程序不好维护！
在函数内部，可以通过全局变量的引用获取对应的数据。
但是，不允许直接修改全局变量的引用——使用赋值语句修改全局变量的值。

# 全部变量
num = 10
def demo1():
    # 希望修改全局变量的值
    # 在Python中，是不允许直接修改全局变量的值
    # 如果使用赋值语句，会在函数内部，定义一个局部变量
    num = 99
    print("在demo1函数内部的变量是%d" % num)
    
def demo2():
    print("在demo2函数内部的变量是%d" % num)

demo1()
demo2()

2）在函数内部修改全局变量的值
如果再在函数中需要修改全局变量，需要使用global进行声明。

# 全部变量
num = 10
def demo1():
    # 希望修改全局变量的值-使用global声明一下变量即可
    # global关键字会告诉解释器后面的变量是一个全局变量
    # 再使用赋值语句时，就不会创建局部变量
    
    global num
    num = 99
    print("在demo1函数内部的变量是%d" % num)
def demo2():
    print("在demo2函数内部的变量是%d" % num)
demo1()
demo2()

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

# 注意：在开发时，应该吧模块中的所有全局变量
# 定义在所有函数上方，就可以保证所有的函数
# 都能够正常的访问到每一个全局变量了

num = 10
# 再定义一个全局变量
aa = "Hello world"
# 再定义一个全局变量
name = "xm"


def demo():
    num = 99
    print("%d" % num)
    print("%s" % aa)
    print("%s" % name)

# 再定义一个全局变量
# aa = "Hello world"

demo()

# 再定义一个全局变量
# name = "xm"

注意：shebang（#！）：是在乌班图的终端下可以文件在Python中运行。

4）全局变量命名的建议

• 为了避免局部变量和全局变量出现混淆，在定义全局变量时，根据公司的要求格式。
• 全部变量名前应该增加g_或者gl_的前缀。
  如果局部变量和全局变量的名字相同时，PyCharm会在局部变量下方显示一个灰色的虚线。

3.函数参数和返回值的作用

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

• 无参数无返回值
• 参数有返回值
• 有参数无返回值
• 有参数有返回值
  
  定义函数时，是否接收参数，或者是否返回结果，是根据实际的功能需求来决定的！
  如果函数内部处理的数据不确定，就可以将外界的数据以参数传递到函数内部。
  如果希望一个函数执行完成后，向外界汇报执行结果，就可以增加函数的返回值。

4.函数的返回值进阶

• 在程序开发中，有时候，会希望一个函数执行结束后，告诉调用者一个结果，以使调用者针对具体的结果做后续的处理。
• 返回值是函数完成工作后，最后给调用者的一个结果。
• 在函数中使用return关键字可以返回结果。
• 调用函数一方，可以使用变量来接收函数的返回结果。
  面试题： 交换两个数字
  题目要求：
  1.有两个整数变量 a=6，b=100
  2.不使用其他变量，交换两个变量的值

a = 6
b = 100
# 解法一：使用其他变量
# c=a
# a=b
# b=c

# 解法二：不使用其他变量
# a = a + b
# b = a - b
# a = a - b
# 解法三：Python 专用
# a, b = (b, a)
# 提示：等号右边是一个元组，只是把小括号省略了
a, b = b, a
print(a)
print(b)

5.函数的参数 进阶

1.不可变和可变的参数

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

可变参数：

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

面试题：+=
在python中，列表变量调用**+=本质上是在执行列表变量的extend**方法，不会改变变量的引用。

def demo(num, num_list):
    print("函数开始")
    # num=num+num
    num += num
    # 列表变量使用+=不会做相加再赋值的操作
    # num_list=num_list+num_list
    # 本质上是在调用列表extends方法
    num_list += num_list
    # num_list.extend(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)
运行结果：
函数开始
18
[1, 2, 3, 1, 2, 3]
函数完成
9
[1, 2, 3, 1, 2, 3]

2.缺省参数

• 定义函数时，可以给某个参数指定一个默认值，具有默认值的参数叫做缺省参数。
• 调用函数时，如果没有传入缺省参数的值，则在函数内部使用定义函数时指定的参数默认值。
• 函数的缺省参数，将常见的值设置为参数的缺省值，从而简化函数的调用。

gl_list = [1, 2, 3]

# 默认按照升序排序,可能会多
gl_list.sort()
# 如果需要降序排序，需要执行reverse参数
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("小美", False)
print_info("小明")

提示：1.缺省参数，需要使用最常见的值作为默认值。
2.如果一个参数的值不能确定，则不应该设置默认值，具体的数值在调用函数时，由外界传递！
注意事项：
1.缺省参数的定义位置
必须保证 带有默认值的缺省参数在参数列表末尾
所以，以下定义是错误的！

def print_info(name, title,gender=True,):

2.调用带有多个缺省参数的函数
在调用函数时，如果有多个缺省参数，需要指定参数名，这样解释器才能知道参数的对应关系！

def print_info(name, title="",gender=True,):
    """
    :param title: 职位
    :param name:班上同学的姓名
    :param  gender：true 男生 False 女生
    """
    gender_text = "男生"

    if not gender:
        gender_text = "女生"
    print("[%s]%s 是 %s" % (title,name,gender_text))
# 假设班上的同学，男生居多！
# 提示：在指定缺省参数的默认值，应该使用最常见的值作为默认值！
print_info("小明")
print_info("小美",gender=False)

3.多值参数（知道）

定义支持多值参数的函数

• 有时可能需要一个函数能够处理的参数个数是不确定的，这个时候，就可以使用多值参数。
• Python中有两种多值参数：
  ①参数名前增加一个 “ * ” 可以接收元组
  ②参数名前增加两个 “ * ” 可以接收字典
• 一般在给多值参数命名时，习惯使用以下两个名字

• *  args(arguments)——存放元组参数，前面有一个*（有变量的意思）
  

• ** kwargs——存放字典参数，前面有两个*
  

• key是keyword的缩写，kwargs可以记忆键值对参数

def demo(num, *nums, **kwargs):
    print(num)
    print(nums)
    print(kwargs)
# demo(1)
demo(1, 2, 3, 4, name="小明", age=10)

提示：多值参数的应用会经常出现在网络上一些大牛开发的框架中，知道多值参数，有利于我们能够读懂大牛的代码。
多值参数案例——计算任意多个数字的和
需求：
1.定义一个函数sum_numbers,可以接收的任意多个整数
2.功能要求：将传递的所有数字累加并且返回累加结果。

# 使用多值参数
def sum_numbers(*args):
    # 这个是使用元组
    # def sum_numbers(args):
    num = 0
    print(args)
    # 循环遍历
    for i in args:
        num += i

    return num
# 元组
# result = sum_numbers((1, 2, 3, 4, 5, 6))
# 使用多值参数
result = sum_numbers(1, 2, 3, 4, 5, 6)
print(result)

4.元组和字典的拆包（知道）

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

• 将一个元组变量，直接传递给args。
• 将一个字典变量，直接传递给kwargs。
  就可以使用拆包，简化参数的传递，拆包的方式是：
• 在元组变量前，增加一个*。
• 在字典变量前，增加两个 *。

def demo(*args, **kwargs):
    print(args)
    print(kwargs)

# 元组变量/字典变量
gl_nums = (1, 2, 3)
gl_dict = {
   "name": "小明", "age": 19}
# demo(gl_nums, gl_dict)z拆包
# 拆包语法，简化元组变量/字典变量的传递
demo(*gl_nums, **gl_dict)
# 不使用拆包
demo(1, 2, 3,name="小明", age= 19)

6.函数的递归

函数调用自身的编程技巧称为递归。

1.递归函数的特点

特点：
一个函数内部调用自己

• 函数内部可以调用其他函数，当然在函数内部也可以调用自己。
  代码的特点：
  1.函数内部的代码是相同的，只是针对参数不同，处理的结果不同。
  2.当参数满足一个条件时，函数不再执行
• 这个非常重要，通常被称为的出口，否则会出现死循环！
  实例代码：

def sum_numbers(num):
    print(num)

    #     递归的出口，当参数满足某个条件时，不再执行函数
    if num == 1:
        return
    #     自己调用自己
    sum_numbers(num - 1)

sum_numbers(3)

2.递归案例——计算数字累加

需求：
1.定义一个函数sum_numbers。
2.能够接收一个num的整数参数。
3.计算1+2+…num的结果。

def sum_numbers(num):
    # 1.出口
    if num == 1:
        return 1
    # 2.数字的累加num+（1...num+1）
    # 假设sum_numbers能够正确的处理1...num-1
    temp = sum_numbers(num-1)
    # 两个数字的相加
    return num + temp


result = sum_numbers(100)
print(result)

提示：递归在处理不确定的循环条件时特别有用，如：遍历整个文件目录的结构。

7.面向对象（oop）基本概念

面向对象编程——Object-oriented programming 。

1.面向对象的基本概念

面向过程和面向对象，是两种不同的编程方式。
对比面向过程的特点，可以更好的了解面向对象。

1.1过程和函数（科普）

过程类似于函数，只能执行，但是没有返回值。
函数不仅能执行，还可以返回结果。

1.2面向过程和面向对象 基本概念

1.面向过程
①把完成某一个需求的所有步骤从头到尾逐步实现。
②根据开发需求，将某些功能独立的代码封装成一个又一个函数。
③最后完成的代码，就是顺序地调用不同的函数。
2.面向对象
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法。
①在完成某一个需求前，首先确定职责――要做的事情（方法）。
②根据职责确定不同的对象，在对象内部封装不同的方法（多个）。
③最后完成的代码就是顺序的，让不同的对象调用不同的方法。
特点：
1.注重对象和职责，不同的对象承担不同的职责。
2.更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供的固定套路。
3.需求在面向过程基础上，再学习一些面向对象的语法。

8.类和对象

1.类和对象的概念

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

1.1类

类是对一群具有相同特征或者行为的事物的一个统称是抽象的，不能直接使用。（是负责创建对象的）
特征被称为属性；行为被称为方法

1.2 对象

对象是由类创建出来的一个具体存在，可以直接使用。
由哪一个类创建出来的对象，就拥有哪一个类中定义的：属性，方法
在程序开发中，应该先有类，再有对象。

2.类和对象的关系

• 类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象。
• 类只有一个，而对象可以有很多个。
  不同的对象之间属性可能会各不相同。
• 类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少。

3.类的设计

在程序开发中，要设计一个类，通常需要满足以下三个要素：
①类名，这类事物的名字满足大驼峰命名法。
②属性，这类事物具有什么样的特征。
③方法，这类事物具有什么样的行为。
大驼峰命名法：CapWords
1.每一个单词的首字母大写
2.单词与单词之间没有下划线

3.1类名的确定

名字提炼法分析整个业务流程，出现的名词，通常就是找到的类

3.2属性和方法的确定

• 对 对象的特征描述通常可以定义成属性
• 对象具有的行为（动词），通常可以定义成方法
  提示：需求中没有涉及的属性或者方法，在设计类时不需要考虑。
  练习
  需求：
  小明今年18岁，身高1.75，每天早上跑完步，会去吃东西。
  小美，今年17岁，身高1.65，小美不跑步，小美喜欢吃东西。
  

9.面向对象基本语法

1.dir内置函数（知道）

在Python中，变量、数据、函数都是对象。
在Python中可以使用两个方法验证：
1.在标识符/数据后输入一个点**.，然后按下Tab键，Python会提示该对象能够调用的方法列表。**
2.使用内置函数dir传入标识符/数据，可以查看对象内的所有属性及方法。
提示：**“方法名”**格式的方法是Python提供的内置方法/属性。

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

面向对象是更大的封装在一个类中封装多个方法，这样通过这个类创建出来的对象就可以直接调用这些方法了。

2.1定义只包含方法的类

• 在Python中要定义一个只包含方法的类.
  语法格式如下:

class 类名
	def 方法1(self,参数列表)
	pass
	def 方法2(self,参数列表)
	pass

• 方法的定义格式和之前学习过的函数几乎一样.
• 区别在于第一个参数必须是self。
  注意:
  类名的命名规则，要符合大驼峰命名法

2.2创建对象

当一个类定义完成之后，要使用这个类来创建对象，语法格式如下：

对象变量=类名（）

2.3第一个面向对象程序

需求：
小猫爱吃鱼，小猫要喝水。
分析:
1.定义一个猫类Cat。
2.定义两个方法eat和drink。
3.按照需求——不需要定义属性。

class Cat:
    """这是一个猫类"""
    def eat(self):
        print("小猫要吃鱼")

    def drink(self):
        print("小猫要喝水")

# 创建猫对象
Tom = Cat()
Tom.eat()
Tom.drink()

引用概念的强调
在面向对象开发中，引用的概念是同样适用的。

• 在Python中使用类创建对象之后，Tom变量中仍然记录的是对象在内存中的地址.
• 也就是Tom变量引用了新建的猫对象.
• 使用print输出对象变量,默认情况下,是能够输出这个变量引用的对象是由哪一个类创建的对象，以及在内存中的地址(16进制表示)
  提示： 在计算机中通常使用16进制，表示内存地址.
  十进制和16进制都是用来表达数字的，只是表示的方式不一样，十进制和16进制的数字之间可以来回转换。
• %d，可以以10进制输出数字
• %x， 可以以16进制输出数字
  案例：使用Cat类再创建一个对象

class Cat:
    """这是一个猫类"""
    def eat(self):
        print("小猫要吃鱼")

    def drink(self):
        print("小猫要喝水")

# 创建对象
Tom = Cat()
Tom.eat()
Tom.drink()
print(Tom)
# 再创建一个猫对象
lazy_cat=Cat()
lazy_cat.eat()
lazy_cat.drink()
print(lazy_cat)

lazy_cats=lazy_cat
print(lazy_cats)
运行结果：

小猫要吃鱼
小猫要喝水
<__main__.Cat object at 0x7f02d1db27f0>
小猫要吃鱼
小猫要喝水
<__main__.Cat object at 0x7f02d1db2898>
<__main__.Cat object at 0x7f02d1db2898>

提问：Tom和lazy_cat是同一个对象吗？
答案：不是，因为他们的内存地址不同。

3.方法中的self参数

3.1案例改造——给对象增加属性
在Python中要给对象设置属性非常的容易，但是不推荐使用。

• 因为对象属性的封装，应该封装在类的内部。
• 只需要在内的外部的代码中直接通过点设置**.**属性即可
  注意:这种方式，虽然简单，但是不推荐使用

class Cat:
    """这是一个猫类"""

    def eat(self):
        print("小猫要吃鱼")

    def drink(self):
        print("小猫要喝水")


# 创建对象
Tom = Cat()
**Tom.name = "Tom"**
Tom.eat()
Tom.drink()
print(Tom)
# 再创建一个猫对象
lazy_cat = Cat()
**lazy_cat.name = "大懒猫"**
lazy_cat.eat()
lazy_cat.drink()
print(lazy_cat)

lazy_cats = lazy_cat
print(lazy_cats)

3.2使用self在方法内部输出每一只猫的名字

由哪一个对象调用的方法，方法内部self就是哪一个对象的引用.
在类封装的方法内部，self 就表示当前调用方法的对象自己.
调用方法时，程序员不需要传递self参数
在方法内部

• 可以通过self访问对象的属性。
• 也可以通过c2复调用其他的对象方法。
  改造代码如下：

class Cat:
    """这是一个猫类"""
    def eat(self):
        # 哪一个对象调用的方法，self就是哪一个对象的引用
        print("%s 要吃鱼"%self.name)
        
# 创建对象
Tom = Cat()
Tom.name = "Tom"
Tom.eat()
# 再创建一个猫对象
lazy_cat = Cat()
lazy_cat.name = "大懒猫"
lazy_cat.eat()

提示：在类的外部，通过变量名.访问对象的属性和方法。
在类封装的方法中，通过self.访问对象的属性和方法。

4.初始化方法

4.1之前代码存在的问题在内的外部给对象增加属性

将案例代码进行调整，先调用方法再设置属性，案例以下执行效果：

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)
Tom.name = "Tom"
程序执行报错如下：
Traceback (most recent call last):
  File "/home/lcj/PycharmProjects/07_语法/lcj—a.py", line 15, in <module>
    Tom.eat()
  File "/home/lcj/PycharmProjects/07_语法/lcj—a.py", line 6, in eat
    print("%s 要吃鱼"%self.name)
AttributeError: 'Cat' object has no attribute 'name'

提示：

• 在日常开发中，不推荐在内的外部给对象增加属性。
  如果在运行时，没有找到属性，程序会报错。
• 对象应该包含有哪些属性，应该封装在类的内部。

4.2初始化方法

• 当使用类名()创建对象时，会自动执行以下操作:
  1.为对象在内存中分配空间——创建对象
  2.维对象的属性设置初始值——初始化方法(init)

• 这个初始化方法就是__init__方法,__init__是对象的内置方法.

__init__方法是专门用来定义一个类具有哪些属性的方法!

class Cat:
    """这是一个猫类"""
    def __init__(self):

        print("这是一个初始化方法")
# 使用类名（）创建对象的时候，会自动调用初始化方法__init__
Tom =Cat()
# print(Tom)

4.3在初始化方法内部定义属性
在__init__方法内部使用self.属性名=属性的初始值就可以定义属性
定义属性之后，再使用Cat类创建的对象，都会拥有该属性。

class Cat:
    """这是一个猫类"""

    def __init__(self):
        print("这是一个初始化方法")
#         self.属性名=属性的初始值
        self.name="Tom"
    def eat(self):
        print("%s 爱吃鱼" % self.name)


# 使用类名（）创建对象的时候，会自动调用初始化方法__init__
Tom =Cat()
Tom.eat()

4.4改造初始化方法——初始化的同时设置初始化

• 在开发中，如果希望在创建对象的同时，就设置对象的属性，可以对__init__方法进行改造。
  ①把希望设置的属性值，定义为__init__方法的参数
  ②在方法内部使用self.属性=形参接受外部传递的参数
  ③在创建对象时，使用类名(属性1，属性2...)调用

class Cat:
    """这是一个猫类"""

    def __init__(self, new_name):
        print("这是一个初始化方法")
        #    self.属性名=属性的初始值
        #    self.name="Tom"
        self.name = new_name

    def eat(self):
        print("%s 爱吃鱼" % self.name)


# 使用类名（）创建对象的时候，会自动调用初始化方法__init__
Tom = Cat("Tom")
print(Tom.name)

lazy_cat = Cat("大懒猫")
lazy_cat.eat()

运行结果：
这是一个初始化方法
Tom
这是一个初始化方法
大懒猫 爱吃鱼

5.内置方法和属性

5.1__del__方法（知道）

在Python中
当使用**类名()**创建对象中，为对象分配完空间后，自动调用__init__方法。
当一个对象被从内存中销毁前，会自动调用__del__方法。
应用场景：

• __init__改造初始化方法，可以让创建对象更加灵活。
• __del__如果做一些事情，可以希望在对象被销毁前，再考虑一下__del__方法。
  生命周期：
• 一个对象从调用类名()创建，生命周期开始。
• 一个对象的__del__方法一旦被调用，生命周期结束。
• 在对象的生命周期内，可以访问对象属性，或者让对象调用方法。

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关键字可以删除一个对象
del Tom
print<