- 一.引言
- 二.为什么要学python，怎么学
- 1.为什么学
- 2.怎么学
- 三.python
- 1.基础语法
- (1)hello world！
- (2)输入输出函数
- （3）注释和双引号
- （4）关键字
- 2.数据类型
- 3.控制语句与循环
- 4.序列：字符串，列表，元组
- 列表
- 元组
- 循环
- 5.映像和集合类型：字典，集合
- 字典
- 集合
- 6.函数
- （1）函数的定义
- （2）函数的使用
- 7.面向对象的编程思想——类和对象
- （1）.面向对象编程介绍
- (2)类和对象
- (3).类的构成
- （4）定义类 和 创建对象
- （5）对象属性获取
- 8.文件操作——输入和输出
- （1）打开文件
- （2）读文件
- （3）写文件
- （4）关闭文件
- 9.模块，包，库，框架
- 10.面向对象编程
- （1）类的创建声明与定义
- （2）类属性
- （3）实例化
- （4）实例属性
- （5）子类和继承，多重继承
恭喜各位同学进入了下一阶段的培训 一.引言
python是动态语言，是既面向对象又面向过程的语言。
二.为什么要学python，怎么学 1.为什么学 2.怎么学和c语言有很大不同的是，python拥有很多拿来即用的自带库和拓展库。
比如数据分析会使用到numpy，matplotlib，pandas等
爬虫会用到requests，beautifulsoup4等
连接数据库会用到pymysql，sqllite3等
深度学习和机器学习会用到tensorflow，pytorch，sklearn等
print("hello world")
(2)输入输出函数
print() input()（3）注释和双引号
这是注释 #这是单行注释 '''这是多行注释哦 '''（4）关键字
| 关键字 | 含义 |
|---|---|
| False | 布尔类型的值，表示与 True 相反 |
| None | None 比较特殊，表示什么也没有，它有自己的数据类型 - None Type |
| True | 布尔类型的值，表示真，与 False相反 |
| and | 用于表达式运算，逻辑与操作 |
| as | 用于类型转换 |
| assert | 断言，用于判断变量或者表示式的值是否为真 |
| break | 中断循环语句的执行 |
| class | 用于定义类 |
| continue | 跳出本次循环，继续执行下一次循环 |
| def | 用于定义函数或方法 |
| del | 删除变量或序列的值 |
| elif | 条件语句，与 if、else 结合使用 |
| else | 条件语句，与 if、else 结合使用；也可以用于异常或循环语句 |
| except | except 包含捕获异常后的操作代码块，与 try、finally 结合使用 |
| finally | 用于异常语句，出现异常后，始终要执行 finally 包含的代码块。与 try、except 结合使用 |
| for | for 循环语句 |
| from | 用于导入模块，与 import 结合使用 |
| global | 定义全局变量 |
| if | 条件语句，与 else、elif 结合使用 |
| import | 用于导入模块，与 from 结合使用 |
| in | 判断变量是否在序列中 |
| is | 判断变量是否为某个类的实例 |
| lambda | 定义匿名函数 |
| nonlocal | 用于表示外部作用域的变量 |
| not | 用于表达式运算，逻辑非操作 |
| or | 用于表达式运算，逻辑或操作 |
| pass | 空的类、方法或函数的占位符 |
| raise | 异常抛出操作 |
| return | 用于从函数返回计算结果 |
| try | try 包含可能会出现异常的语句，与 except、finally 结合使用 |
| while | while 循环语句 |
| with | 简化 Python语句 |
| yield | 用于从函数一次返回值 |
Python3 中有六个标准的数据类型：
-
number（数字）
-
string（字符串）
-
tuple（元组）
-
list（列表）
-
set（集合）
-
dictionary（字典）
for 循环变量 in 集合： 操作 while ……： 操作4.序列：字符串，列表，元组
字符串和c语言大差不差
单引号 '' 双引号 "" 多引号 """""" ''''''列表
列表使用[ ]闭合定义，元素可以是任意类型的，可以多种类型混合使用。
list=[1,3.14,"CSDN","列表",2,4,"傻"]
列表常用内置函数
| 名称 | 作用 |
|---|---|
| list.append() | 追加 |
| list.count(x) | 计算列表中参数 |
| list.extend(L) | 向列表中追加另一个列表L |
| list.index(x) | 获得参数x在列表中的位置 |
| list.insert(x,y) | 向列表中的x位置插入数据 y |
| list.pop(index) | 删除列表中下标为index的元素 （ 通 过 下 标 删 除 ） color{#FF0000}{ （通过下标删除） } （通过下标删除） |
| list.remove(x) | 删除列表中指定元素x （ 直 接 删 除 ） color{#FF0000}{（直接删除）} （直接删除） |
| list.reverse() | 将列表中的元素颠倒顺序 |
| list.sort() | 将列表中的元素进行排序 貌 似 这 里 的 列 表 元 素 数 据 类 型 必 须 相 同 不 然 报 错 color{#FF0000}{貌似这里的列表元素数据类型必须相同不然报错} 貌似这里的列表元素数据类型必须相同不然报错 |
下面将展示代码实例：
append
list=[1,3.14,"CSDN","列表",2,4," "] list.append(1) print(list) ———————————————————————————————————————————————————————— [1, 3.14, 'CSDN', '列表', 2, 4, ' ', 1] Process finished with exit code 0
实验证明append只能一次添加一个元素
list=[1,3.14,"CSDN","列表",2,4," "] list.append(1,2,3) print(list) _____________________________________________________________ Traceback (most recent call last): File "C:/Users/gedin/PycharmProjects/pythonProject/t1/pratice02.py", line 4, inlist.append(1,2) TypeError: append() takes exactly one argument (2 given) Process finished with exit code 1
count
list=[1,3.14,"CSDN","列表",2,4," "] print(list.count(1)) ———————————————————————————————————————————————————————————————————————————————— 1 Process finished with exit code 0
extend
list=[1,3.14,"CSDN","列表",2,4," "] list1=['hello'] list.extend([1,2,3]+list1) print(list) —————————————————————————————————————————————————————————————————————————————————— [1, 3.14, 'CSDN', '列表', 2, 4, ' ', 1, 2, 3, 'hello'] Process finished with exit code 0元组
和列表差不多元组用（）来定义
但是元组的元素是不能改变的
tuple=(3.14,'中国',3,'hello',5)
因为元组的元素是不可改变的所以内置的方法也少的可怜
| 常见方法 | 作用 |
|---|---|
| count() | 查找指定元素在元组里出现的次数 |
| index() | 查找指定元素第一次在元组里出现的索引值 |
tuple=(3.14,'中国',3,'hello',5)
print("元素5的下标:"+str(tuple.index(5)))
print("元素5出现的次数:"+str(tuple.count(5)))
————————————————————————————————————————————————————————————————————————————————————————————————————
元素5的下标:4
元素5出现的次数:1
Process finished with exit code 0
循环
python的循环简介优雅功能强大：
Html。。。。。
for i in range(1,10):
for j in range(1,i+1):
print(str(j)+'*'+str(i)+'='+str(i*j)+' ',end='')
print()
--------------------------------------------------------------------------------
"D:Program Files (x86)pythonpython.exe" C:/Users/gedin/PycharmProjects/pythonProject/t1/pratice02.py
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
Process finished with exit code 0
for i in range(10):
print("Hello world!!!")
-----------------------------------------------------------------------------------
"D:Program Files (x86)pythonpython.exe" C:/Users/gedin/PycharmProjects/pythonProject/t1/pratice02.py
Hello world!!!
Hello world!!!
Hello world!!!
Hello world!!!
Hello world!!!
Hello world!!!
Hello world!!!
Hello world!!!
Hello world!!!
Hello world!!!
Process finished with exit code 0
i=1
while i<10:
print("Hello World!!!")
i+=1
—-------------------------------------------------------------------------------------
"D:Program Files (x86)pythonpython.exe" C:/Users/gedin/PycharmProjects/pythonProject/t1/pratice02.py
Hello World!!!
Hello World!!!
Hello World!!!
Hello World!!!
Hello World!!!
Hello World!!!
Hello World!!!
Hello World!!!
Hello World!!!
Process finished with exit code 0
5.映像和集合类型：字典，集合
字典
字典使用{ }来定义，里面的元素必须为键值对key：value且键的值是不可遍的（数字，字符串，元组）
dict={1:'China',2:'CSDN',3:3.14,4:'hello',5:'哈哈哈'}
| 常见方法 | 作用 |
|---|---|
| dict.copy() | |
| dict.fromkeys(list,[,]) | |
list=[1,2,3,4,5]
list1=[]
list2=[5,4,3,2,1]
dict1=dict.fromkeys(list,[1,2,3,4])
print(dict1)
dict2=dict.fromkeys(list1)
print(dict2)
dict3=dict.fromkeys(list2,[1,2,3])
print(dict3)
_____________________________________________________________________________
{1: [1, 2, 3, 4], 2: [1, 2, 3, 4], 3: [1, 2, 3, 4], 4: [1, 2, 3, 4], 5: [1, 2, 3, 4]}
{}
{5: [1, 2, 3], 4: [1, 2, 3], 3: [1, 2, 3], 2: [1, 2, 3], 1: [1, 2, 3]}
Process finished with exit code 0
集合
数学中集合的定义
- 确定性
给定一个集合，任给一个元素，该元素或者属于或者不属于该集合，二者必居其一，不允许有模棱两可的情况出现 [6] 。 - 互异性
一个集合中，任何两个元素都认为是不相同的，即每个元素只能出现一次。有时需要对同一元素出现多次的情形进行刻画，可以使用多重集，其中的元素允许出现多次 [6] 。 - 无序性
一个集合中，每个元素的地位都是相同的，元素之间是无序的。集合上可以定义序关系，定义了序关系后，元素之间就可以按照序关系排序。但就集合本身的特性而言，元素之间没有必然的序 [6] 。
创建集合
python set类是在python的sets模块中，大家现在使用的python3.6.x中，不需要导入sets模块可以直接创建集合。
>>>set('boy')
set(['y', 'b', 'o'])
集合添加、删除
python 集合的添加有两种常用方法，分别是add和update。
集合add方法：是把要传入的元素做为一个整个添加到集合中，例如：
>>> a = set('boy')
>>> a.add('python')
>>> a
set(['y', 'python', 'b', 'o'])
集合update方法：是把要传入的元素拆分，做为个体传入到集合中，例如：
>>> a = set('boy')
>>> a.update('python')
>>> a
set(['b', 'h', 'o', 'n', 'p', 't', 'y'])
集合删除操作方法：remove
set(['y', 'python', 'b', 'o'])
>>> a.remove('python')
>>> a
set(['y', 'b', 'o'])
python set() 集合操作符号、数学符号
集合的交集、合集（并集）、差集，了解python集合set与列表list的这些非常好用的功能前，要先了解一些集合操作符号
有关这些数学知识将会再大一下的离散数学中学到
·如今主流的软件开发思想有两种：一个是面向过程，另一个是面向对象。面向过程出现得较早，典型代表为C语言，开发中小型项目的效率很高，但是很难适用于如今主流的大中型项目开发场景。面向对象则出现得更晚一些，典型代表为Java或C++等语言，更加适合用于大型开发场景。两种开发思想各有长短。
·对于面向过程的思想： 需要实现一个功能的时候,看重的是开发的步骤和过程,每一个步骤都需要自己亲力亲为,需要自己编写代码(自己来做)
对于面向对象的思想：当需要实现一个功能的时候,看重的并不是过程和步骤,而是关心谁帮我做这件事(偷懒,找人帮我做)
·面向对象的三大特征有: 封装性、继承性、多态性。
生活举例
洗衣服
面向过程（手洗）： 脱衣服、找一个盆、加水、加洗衣粉、浸泡30分钟、搓洗、拧衣服、倒掉水、再加水、漂洗、拧衣服、倒掉水、晾衣服。
面向对象（机洗）： 脱衣服、放入洗衣机、按下开关、拿出衣服晾晒。
买电脑
面向过程（自己买）： 需要电脑、查询参数信息、横向比较机型、了解打折信息、与店家讨价还价、下单、收快递、开机验货、确认收货。
面向对象（找人买）： 需要电脑、找秘书帮我买、收电脑。
(2)类和对象-
`对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另外一个新的概念——类
-
面向对象的语言当中，“类”就是用来模拟现实事物的。
-
类：抽象的，是一张“手机设计图”。
-
对象：具体的，是一个“真正的手机实例”。
-
小结： 类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在。一个类可以找到多个对象。
这一部分不是短时间内就可以完全理解的，需要在实际操作中慢慢体会
人以类聚 物以群分。
具有相似内部状态和运动规律的实体的集合(或统称为抽象)。
具有相同属性和行为事物的统称
- 类就相当于制造飞机时的图纸，用它来进行创建的飞机就相当于对象 类是一类事物，对象即是这类事物实现
- 类中也有属性、行为两个组成部分，而“对象”是类的具体实例
- 属性： 事物的特征描述信息，用于描述某个特征“是什么”。
- 行为： 事物的能力行动方案，用于说明事物“能做什么”。
类(Class) 由3个部分构成
- 类的名称:类名
- 类的属性:一组数据
- 类的方法:允许对进行操作的方法 (行为)
案例：如下植物大战僵尸可以抽象为几个类
向日葵
类名: xrk
属性: 颜色
行为: 放阳光 死亡
豌豆
类名: wd
属性: 颜色 、发型,血量
行为:发炮, 摇头 死亡
坚果:
类名:jg
属性:血量 类型
行为:阻挡;死亡
（4）定义类 和 创建对象僵尸: 类名:js
属性:颜色、血量、 类型、速度
行为:走 跑跳 吃 死亡
- 定义一个类，格式如下：
class 类名:
方法列表
- demo：定义一个Hero类
# class Hero: # 经典类（旧式类）定义形式
# class Hero():
class Hero(object): # 新式类定义形式
def info(self):
print("英雄各有见，何必问出处。")
- 说明：
- ①定义类时有2种形式：新式类和经典类，上面代码中的Hero为新式类，前两行注释部分则为经典类；
- ②object 是Python 里所有类的最顶级父类；
- ③类名 的命名规则按照"大驼峰命名法"；
- ④info 是一个实例方法，第一个参数一般是self，表示实例对象本身，当然了可以将self换为其它的名字，其作用是一个变量这个变量指向了实例对象
python中，可以根据已经定义的类去创建出一个或多个对象。
创建对象的格式为:
对象名1 = 类名() 对象名2 = 类名() 对象名3 = 类名()
创建对象demo:
class Hero(object): # 新式类定义形式
"""info 是一个实例方法，类对象可以调用实例方法，实例方法的第一个参数一定是self"""
def info(self):
"""当对象调用实例方法时，Python会自动将对象本身的引用做为参数，
传递到实例方法的第一个参数self里"""
print(self)
print("self各不同，对象是出处。")
# Hero这个类 实例化了一个对象 taidamier(泰达米尔)
taidamier = Hero()
# 对象调用实例方法info()，执行info()里的代码
# . 表示选择属性或者方法
taidamier.info()
print(taidamier) # 打印对象，则默认打印对象在内存的地址，结果等同于info里的print(self)
print(id(taidamier)) # id(taidamier) 则是内存地址的十进制形式表示
<__main__.Hero object at 0x036EB0D0> self各不同，对象是出处。 <__main__.Hero object at 0x036EB0D0> 57585872
小结：当创建一个对象时，就是用一个模子，来制造一个实物
（5）对象属性获取对象既然有实例方法，是否也可以有自己的属性?
添加和获取对象的属性
class Hero(object):
"""定义了一个英雄类，可以移动和攻击"""
def move(self):
"""实例方法"""
print("正在前往事发地点...")
def attack(self):
"""实例方法"""
print("发出了一招强力的普通攻击...")
# 实例化了一个英雄对象 泰达米尔
taidamier = Hero()
# 给对象添加属性，以及对应的属性值
taidamier.name = "泰达米尔" # 姓名
taidamier.hp = 2600 # 生命值
taidamier.atk = 450 # 攻击力
taidamier.armor = 200 # 护甲值
# 通过.成员选择运算符，获取对象的属性值
print("英雄 %s 的生命值 :%d" % (taidamier.name, taidamier.hp))
print("英雄 %s 的攻击力 :%d" % (taidamier.name, taidamier.atk))
print("英雄 %s 的护甲值 :%d" % (taidamier.name, taidamier.armor))
# 通过.成员选择运算符，获取对象的实例方法
taidamier.move()
taidamier.attack()
英雄 泰达米尔 的生命值 :2600 英雄 泰达米尔 的攻击力 :450 英雄 泰达米尔 的护甲值 :200 正在前往事发地点... 发出了一招强力的普通攻击...
对象创建并添加属性后，能否在类的实例方法里获取这些属性呢？如果可以的话，应该通过什么方式？
在方法内通过self获取对象属性
class Hero(object):
"""定义了一个英雄类，可以移动和攻击"""
def move(self):
"""实例方法"""
print("正在前往事发地点...")
def attack(self):
"""实例方法"""
print("发出了一招强力的普通攻击...")
def info(self):
"""在类的实例方法中，通过self获取该对象的属性"""
print("英雄 %s 的生命值 :%d" % (self.name, self.hp))
print("英雄 %s 的攻击力 :%d" % (self.name, self.atk))
print("英雄 %s 的护甲值 :%d" % (self.name, self.armor))
# 实例化了一个英雄对象 泰达米尔
taidamier = Hero()
# 给对象添加属性，以及对应的属性值
taidamier.name = "泰达米尔" # 姓名
taidamier.hp = 2600 # 生命值
taidamier.atk = 450 # 攻击力
taidamier.armor = 200 # 护甲值
# 通过.成员选择运算符，获取对象的实例方法
taidamier.info() # 只需要调用实例方法info()，即可获取英雄的属性
taidamier.move()
taidamier.attack()
英雄 泰达米尔 的生命值 :2600 英雄 泰达米尔 的攻击力 :450 英雄 泰达米尔 的护甲值 :200 正在前往事发地点... 发出了一招强力的普通攻击...8.文件操作——输入和输出 （1）打开文件
在python中使用open函数即可打开文件
f = open(‘test.txt’,’w’)
访问模式
| 访问模式 | 说明 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| w | 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a+ | 打开一个文件用于读写，如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果改文件不存在，创建新文件用于读写。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头 |
| wb+ | 以二进制格式打开一个文件用于读写。如果改文件已存在则会覆盖。如果改文件不存在，创建新文件。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果改文件不存在，创建新文件用于读写。 |
使用write()可以完后向文件写入数据
示例
#写
f = open("test.txt","w") #打开文件，w模式（写模式），文件不存在就新建
f.write("hello world,I am here!") #将字符串写入文件中
f.close() #关闭文件
（3）写文件
（4）关闭文件
#新建一个文件，文件名为：test.txt f = open(“text.txt”,”w”) f.colse()#关闭这个文件9.模块，包，库，框架
（1）模块：是一个单独的.py文件，用于存放一些功能相关的代码，可以是代码更加容易维护，提高代码的重用价值
（2）包：是一个有层级的目录结构，包含n个模块或者n个子包，包中一定要有__init__.py文件
（3）库：是完成一定功能的代码集合，表现形式是一个模块，或包
（4）框架：是一个架构层面的概念，为解决一个开放性问题而设计的具有一定约束性的支撑结构，通过框架可以快速实现一个解决问题的骨架，后面按照框架中的角色去填充和交互，就可以完成质量高，维护性强的项目
（5）包和模块的作用：1.有效的对程序进行分解，方便代码的管理和维护，如造一辆车，就得先造好轮子、发动机和壳等小的零件，再将这些小零件组合，就可以做成车，同样，拿模块和包过来就可以则合成大的程序；2.避免同一模块中命名重复问题
关于包和模块的分类
（1）标准包和模块：安装python后自动下载在电脑中的包和模块，可以直接导入使用，满足用户基本的需求；其中有一些特殊的包和模块–内建包和模块，如builtins模块，其中包含了很多如print这样的常用的方法，所以内建包和模块不需要导入就可以直接使用
（2）三方包和模块：别的程序员开发的包和模块，需要用户手动去相关网站上下载安装，然后进行导入使用
（3）自定义包和模块：用户自己写的一些好的包和模块
关于包和模块的信息
（1）包和模块名：包名是包的名称，模块名是.py文件的名称
（2）包和模块位置：可以通过“print(模块.file)”来查看包和模块的位置信息
（3）包和模块中的内容：可以通过“print(dir(模块))”来查看列出的包和模块中的内容
关于python不同版本之间不兼容的问题
（1）不兼容对象：包和模块
（2）不兼容原因：包和模块中存在一些类，函数和属性等，如果有两个版本，1.f前者有一个名为a的函数，而后者没有；2两者都有名为b的函数，但前者只传一个参数，后者要传两个参数；3.前者本来没有名为c的函数，但后者却有。这些情况都将导致两个版本的python不兼容
关于包和模块的导入（重点）
（1）作用：可以使用包和模块中的好的模块和方法等工具
（2）包的导入方式
常规导入：方式1.import M；方式2.import M1,M2；方式3.import M as 别名。如果导入的是一个包中的模块，则需要使用“.”语法，如import 包.模块
注意：使用导入的模块中的内容时，要使用“.”语法，如M.run()，即使用导入的M模块中的run()方法
补充：直接导入一个包，则不会导入任何包中的模块，但是会执行包中的__init__.py文件的内容，这里的解决方法是1.再在__init__.py文件中对需要的模块进行导入（使用绝对路径）；2.使用from 包 import 模块的形式进行导入
from A import B：使用此方式导入模块时，B一定只能写一个模块名，不能带有“.”语法，而A可以是一个包，也可以是包中的子包，可以使用“.”语法，如from 包.子包 import 模块。这里需要注意的是python中的一种面向关系，即包中只能看到模块，不能看到模块中的资源，而模块只能看见其中的资源，不能看见别的东西
from A import *（重点）：这种导入方式如果是将模块中的所用资源导入过来使用，那么这里的A只能是模块；如果A是包，则是将该包中所有的模块都导入进来。需要注意的是，这里有两种特殊情况，1.在A模块中使用__all__=[“a”,“b()”]属性时，则使用from A import *进行导入后就只能使用列表中写的属性和方法，如果没有写__all__=[“a”,“b()”]属性，则默认可以使用A中所有的资源；2.如果A中存在受保护的或者私有的资源，则必须使用__all__=["_a","__b()"]属性进行说明，否则直接使用from A import *进行导入后，仍然无法使用这些资源
————————————————
版权声明：本文为CSDN博主「醍醐三叶」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/zx870121209/article/details/81515649
