1. 什么是对象：python中一切皆为对象！—PPT
程序运行当中，所有数据都是储存到内存当中再运行的。
对象就是内存中专门用来存储数据的一块区域。
对象实际上就是一个容器，专门用来存储各种数据.（比如：数值、字符串、布尔值、None、代码、函数等都是对象）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zyc0oafv-1584151055406)(attachment:image.png)]
a=123
type(a)
int
type(1.5)
float
type("hello")
str
type("True")
str
type(True)
bool
type(None)
NoneType
2. 对象的结构：
id(标识)：用来标识对象的唯一性。
每一个对象都有自己唯一的id（就像人的身份证号）。
通过id( )函数查看对象的id。id是由解析器生成的。
对象一旦创建，则它的id永远不变。
type(类型)：当前对象所属的类型：int,str,float等等。
类型决定了对象的功能（骑自行车）。
通过type( )函数查看对象的类型。
python是一门强类型的语言，对象一旦创建类型就不能再修改。
value (值)：对象存储的具体数据。有些对象的值是可以改变的。对象分为两大类：可变对象和不可变对象
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iS5QAUNU-1584151055408)(attachment:image.png)]
a=123
print(id(a))
print(type(a))
140736823272064
<class 'int'>
a=123
b=123
print(id(a),id(b))
print(type(a),type(b))
140736425271936 140736425271936
<class 'int'> <class 'int'>
b='hello'
print(id(b))
print(type(b))
2579620983672
<class 'str'>
c=True
print(id(c))
print(type(c))
140724141529424
<class 'bool'>
3 可变对象：当改变对象内部的值的时候，这个对象的id不发生变化。
3.1常见可变对象：字典(dict), 集合(set), 列表(list)。下面以列表为例子：
a_list=['cuc',2,[4,5]]
print(a_list)
print(id(a_list))
#改变列表的第三个元素
print('改变列表的第三个元素后：')
a_list[2]=[3,4]
print(a_list)
print(id(a_list))
#b_list=['cuc',2,[3,4]]
#print(b_list)
#print(id(b_list))
#a_list is b_list
['cuc', 2, [4, 5]]
3027017448008
改变列表的第三个元素后：
['cuc', 2, [3, 4]]
3027017448008
3.2不可变对象：当改变对象内部的值的时候，这个对象的id会发生变化。
常见不可变对象：整型(int), 字符串(string), 浮点型(float), 元组(tuple)。五个场景看清不可变对象在python中的端倪
场景1：int值比较小，属于【-25，257）时，值一样的变量id就一样。值变化id就变化。
a=5
b=5
c=6
print(id(a))
print(id(b))
print(id(c))
a is b
140724134253504
140724134253504
140724134253536
True
场景2：int值比较大，不属于【-25，257）时，值一样的变量id不一样不一样不一样。值变化id就变化。
a=257
b=257
c=258
print(id(a))
print(id(b))
print(id(c))
a is b
3027022019760
3027022020080
3027022019920
False
场景3: float 值一样的变量id也不一样。值变化id就变化
f=1.1
h=1.1
g=1.2
print(id(f))
print(id(h))
print(id(g))
f is h
2029014431112
2029014431136
2029014430968
False
场景4: tuple 值一样的变量id也不一样。值变化id就变化
a_tuple=(1,2,3)
b_tuple=(1,2,3)
c_tuple=(4,5,6)
print(id(a_tuple))
print(id(b_tuple))
print(id(c_tuple))
a_tuple is b_tuple
3027018615400
3027018615760
3027018438552
False
场景5: 单词类型的str 类型的值一样的变量id都一样。值变化的id就变化
str1='hello'
str2='hello'
str3='CUC'
print(id(str1))
print(id(str2))
print(id(str3))
str1 is str2
3027022240376
3027022240376
3027022240320
True
场景5.2: 非单词类型的str 类型的值一样的id不一样。值变化的id就变化
str1='welcome to CUC'
str2='welcome to CUC'
str3='welcome to China'
print(id(str1))
print(id(str2))
print(id(str3))
str1 is str2
2029014866288
2029014994288
2029014979040
False
str1='中'
str2='中'
str3='国'
print(id(str1))
print(id(str2))
print(id(str3))
str1 is str2
3027022028592
3027022028672
3027022319664
False
str1='中国传媒大学'
str2='中国传媒大学'
str3='数智学院'
print(id(str1))
print(id(str2))
print(id(str3))
str1 is str2
3027022311920
3027022312032
3027021339328
False
由这些现象说四个内部实现：
int 类型解析
较小的整数会很频繁的被使用，所以python将这些对象放置到了一个池子(常量池)中，每次需要这些对象的时候就到池子中获取这个值，避免多次的重复创建对象引起的许多不必要的开销。这个池子内的数字范围是[-25, 257), 所以都是从池子里面取值，自然id不变。
float类型解析
对于float类型的使用自然没有int那么频繁，并且float类型也不好定义哪些常用，也就没有池子给到这个类型，所以每次重新创建即可。
tuple类型解析
对于tuple类型，与float类型的思维相似，所以也是每次重新创建。
string类型解析
单词类型的str由于被重复使用的概率比较大，所以在python中为单词类型的str做了一个缓存，也就是说如果是单词类型的str， 会被存储到一个字典(dict)中，字典的内容是字符串为key， 地址为value。当有一个字符串需要创建，就先去访问这个字典，如果存在则返回字典中字符串的地址，如果不存在，则返回新创建的地址，并将这个字符串添加进入字典。这是字符串的intern机制
4.变量和对象—PPT
a=3，并不是将3赋值给变量a，在python中一定要摆脱这种思维模式。
对象并没有直接存储到变量中。在python中的变量更像是对象的一个别名（贴标签）
如下例，没有命名的变量，报错“name ‘cxy’ is not defined”。变量更像是一个名字
cxy
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-5-0e18932addf6> in <module>
----> 1 cxy
NameError: name 'cxy' is not defined
变量中存储的不是对象的值，而是对象的id（内存地址）。当使用变量时，实际上是通过对象id查找对象
变量中保存的对象id,只有在为变量重新赋值时才会改变
变量与变量之间相互独立，修改一个变量不会影响其他变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rPRMpL8V-1584151055409)(attachment:image.png)]
5.面向对象（oop）
面向过程的编程语言，指将程序的逻辑分解为一个一个的步骤，通过对每个步骤的抽象来完成程序。
面向过程的编程思想：将一个功能分解为一个一个小的步骤。
优点：符合人类思维，编写相对简单；缺点：只适用于一个功能，可复用性比较低，并难于维护。
面向对象的编程语言，指一切操作都是通过对象来进行的。关注的是对象而不是过程。
面向对象的思想：将所有的功能统一保存到对应的对象中。要使用某个功能，直接找到对应的对象即可。
优点：易于阅读和维护，可复用性高，缺点：不太符合常规的思维，编写较为繁琐。
