小小总结，写得有些乱
字符串：
字符串常用方法：
# -*- coding:utf-8 -*-
# author:ke_T\
name = "ke_T"
print(name.capitalize()) #首字母大写,但是不改变name值
print(name.count("k")) #寻找这个字符串中k这个字符串出现的次数
print(name.center(3,"*")) #这个10时一种占的长度，不够的话，用*补充，够的话则不用
print(name.endswith("T")) #判断是否以某字符串结尾
print(name.find("k")) #找到这个字符串的索引，这里k，返回0
print(name.isalnum()) #判断是否为阿拉伯字母或者数字
print(name.isalpha()) #判断是否为英文
print(name.isidentifier()) #判断是否是合法的标识符，中文也是合法的但是想*这些就不是的，下划线合法哦
print(name.islower())
print(name.strip()) #忽略空格还有换行符
# s随机密码的生成模式
p = str.maketrans("abcd","1903")
print("asdjsd".translate(p)) #生成结果1s3js3
print("kekkq".replace('ke','q',2)) #第一个参数，要替换的字符，第二个参数，替换成什么字符，第三个参数，替换几个，不写默认全部替换.
#当然，也可以替换字符串
print("kksad aa".rfind('a')) #找到该字符串最后出现的位置
print("bbq qc".title()) #变成标题的形式，就是首字母大写
列表：
列表是python中最常见的数据类型，它可以作为一个方括号内的都好分隔值出现，列表中的值不需要是同一个类型。
import copy
names = ["kejinxun","keteng","huangchunxiao","xieyuanyi","liuchenggong","mahuateng"]
print(names[1])#根据下标去数据
print(names[1:2])#根据范围取出数据,取出的是个列表，这里取出的列表为['keteng']，因为这种方式的特点是，取头不取尾
print(names[1:3][1])#根据范围取出的列表，再拿数据的方式也就是列表拿数据的方式结果为huangchunxiao
print(copy.copy(names))#列表的复制，引入copy模块，调用copy函数,浅copy,就是不会独立的列表，指向同一个内存地址，深copy，则是用copy模块的copy函数，这样子会重新开辟一个内存，存放另一个列表
print(names[-3:-1])#负数，从列表右边往左数起，因此结果为['xieyuanyi', 'liuchenggong']
print(names[names.index("keteng")]) #keteng,根据元素内容找到下标，然后在通过下标，返回元素
#列表元素的插入
names.append("chenxiaomei")#直接在列表后边添加元素
print(names)#打印结果为['kejinxun', 'keteng', 'huangchunxiao', 'xieyuanyi', 'liuchenggong', 'mahuateng', 'chenxiaomei']
names.insert(1,"ke") #按照下标插入
print(names) #打印结果为['kejinxun', 'ke', 'keteng', 'huangchunxiao', 'xieyuanyi', 'liuchenggong', 'mahuateng', 'chenxiaomei']
#列表元素的删除
names.remove("ke")#根据名字删除
print(names) #['kejinxun', 'keteng', 'huangchunxiao', 'xieyuanyi', 'liuchenggong', 'mahuateng', 'chenxiaomei']
names.pop() #直接移除最后的那个元素
print(names) #['kejinxun', 'keteng', 'huangchunxiao', 'xieyuanyi', 'liuchenggong', 'mahuateng']
names.pop(1) #移除下标为1的元素
print(names) #打印结果为['kejinxun', 'huangchunxiao', 'xieyuanyi', 'liuchenggong', 'mahuateng']
#列表常用功能
names.reverse() #反转
print(names) #['mahuateng', 'liuchenggong', 'xieyuanyi', 'huangchunxiao', 'kejinxun']
names.sort() #排序,根据Ascii排序
print(names) #['huangchunxiao', 'kejinxun', 'liuchenggong', 'mahuateng', 'xieyuanyi']
name = [1,2,3]
names.extend(name) #继承
print(names) #['huangchunxiao', 'kejinxun', 'liuchenggong', 'mahuateng', 'xieyuanyi', 1, 2, 3]
name.extend(name)
print(name) #[1, 2, 3, 1, 2, 3]
name.append("bbc")
name.append("bbc")
print(name)
print(name.index("bbc")) #只要找到最开始出现的那一次，就退出，并返回该下标
#循环
for i in name: #i指向了name，打印了相当于name[下标的东西]
print(i)
print(name[::1]) #[1, 2, 3, 1, 2, 3, 'bbc', 'bbc']
print(name[1::]) #[2, 3, 1, 2, 3, 'bbc', 'bbc'],这样子的形式，name[i:j:k],
# i表示开始的下标，即表示结束的下标，k表示隔着几个遍历，i默认为0，j默认为列表的长度，k默认为1
#列表删除某个元素
del name[1]
print(3 in [1,2,3]) #查询某个元素是否在这个列表
字典：
字典是key-value的形式，是Python中的唯一的映射类型，它是无序的，因此像列表那样不能通过下标来访问，字典中的键是唯一的，值不唯一。特点：
- 键与值用冒号:分开；
- 2.项与项用逗号,分开
- 字典的键必须唯一
访问字典的值：
Addict[key]，存在则返回值，不存在则返回keyError错误。
修改字典的值：
Addict[key] = 内容，如果存在该key，则会修改该key的值，如果不存在，则会增加这个键
删除字典的值：
和列表一样，用del addict[key]
更新字典：
info = {
'001': "keteng",
'002': "wuzetian",
'003': "liuchenggong"
}
info2 = {"bbc":[1,2],
'002':{'c':'cvd'}}
info.update(info2) #同key的，则改变原字典的，不同的则加入
print(info)
字典的遍历：
for i in info: #遍历字典，i指向了key
print(i,info[i])
for k,v in info.items(): #遍历字典，k指向key，v指向了value
print(k,v)
元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
访问元组
元组可以使用下标索引来访问元组中的值
修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下
yuzu1 = (1,2,3)
yuzu2 = (2,3,4)
yuanzu3 = yuzu1 + yuzu2
print(yuanzu3)
不过我总觉得没有多大的意义。
删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
yuzu1 = (1,2,3)
yuzu2 = (2,3,4)
del yuzu1
print(yuzu1)
输出之后会报错哦NameError: name 'yuzu1' is not defined
元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
|
Python 表达式 |
结果 |
描述 |
|
len((1, 2, 3)) |
3 |
计算元素个数 |
|
(1, 2, 3) + (4, 5, 6) |
(1, 2, 3, 4, 5, 6) |
连接 |
|
('Hi!',) * 4 |
('Hi!', 'Hi!', 'Hi!', 'Hi!') |
复制 |
|
3 in (1, 2, 3) |
True |
元素是否存在 |
|
for x in (1, 2, 3): print x, |
1 2 3 |
迭代 |
函数
函数就很重要的啦，函数的形式为def 函数名（），函数还分为无参函数，有参函数，还有缺省函数，匿名函数
无参函数：
def tes1():
这个就是无参函数的表现形式啦
有参函数
def test(a,b):
缺省函数
def test(a,d,b=22,c=33):
print(a)
print(b)
print(c)
print(d)
test(d=11,a=22,c=44)
这个就是缺省函数例子，一定例子要至少输入两个参数，因为a,d没有赋值。
还有传进的是元组和字典时，需要字符标识
def test(a,b,c=33,*args,**kwargs):#在定义的时候 *,**用来表示后面的变量有特殊功能
print(a)
print(b)
print(c)
print(args)
print(kwargs)
#test(11,22,33,44,55,66,77,task=99,done=89)
def test1(**a):
print(a["name"])
A = (44,55,66)
B = {"name":"laowang","age":18}
test(11,22,33,*A,**B)#在实参中*,**表示对元祖/字典进行拆包
test1(**B)
匿名函数
lambda，匿名函数的声明
应用实例
infors = [{"name":"laowang","age":10},{"name":"xiaoming","age":20},{"name":"banzhang","age":10}]
infors.sort(key=lambda x:x['age'])
print(infors)
我来解释下这个例子吧。首先因为列表正常来说是可以用sort直接排序的，但是由于列表中的元素是字典类型，它不知道按照什么来排序，所以我们需要告诉列表以什么来排，因此这里调用匿名函数，lambda x:x[‘age’]返回age的大小，这样子，就完成了排序。
拓展：
a = [100]
b=[200]
def test2(num,num2):
num +=num
num2 = num2 + num2
print(num,num2)
test2(a,b)
print(a,b)
你觉得输出结果是什么呢？
在不了解之前，我想着是输出
[100, 100] [200, 200]
[100, 100] [200, 200]
但是实际上不是，num+=num并不等于num = num +num,b并没有改变，因为num2 = num2+num2中，num2+num2是开辟了一个新内存,然后，num2指向了这个新内存。
对象
什么是对象，车，人，电脑都是对象，应该说一切皆对象。而对象会有属性，比如人，身高就是他的属性之一。对象还有方法，这个方法又是什么呢？比如有的人会游泳，这个游泳就是方法，有了游泳这个方法，这个人的这个对象就会游泳，会谈吉他，则他有会谈吉他的方法。
对象的构造方法，构造方法则是对于一个对象的初始化，比如一辆车，制造出来之前是否应该有模型呢？照着这个模型的参数不就可以做出车子。因此通过构造方法初始化对象就是这么一回事。而构造方法有参数的时候，就是定制不一样的车子，宝马和桑塔纳能一样吗？它们之间因为构造参数的不同，因此造出来的对象不同。好了，我感觉自己扯犊子了，嘻嘻。还是正经点首先说下对象的构造方法，在Python中，一般构造方法的命名有规范，一般在构造函数前后使用两个下划线，__init__（）。
觉得对象这里好像没有什么特别要说的，对象添加属性就是实例化的对象.属性名 = 什么，如果存在该属性名，则更改该属性的值，如果不存在，则添加新属性。我觉得有个很需要注意得就是，对象中的函数，都有个self参数，这个代表对象本身，如果修改对象本身的值，则需要self.属性名 = xxx，以此完成赋值。
忘记了，对象的私有变量也是很重要的。 首先一定要双下划线开始，这就代表着定义了一个私有变量，self.__age = 0#定义了一个私有的属性,属性的名字是__age
私有方法，则和私有属性定义一样，也是双下划线开头，才会被认定为是私有方法。
对象的继承
继承是什么样的概念？还是以车为例子，是不是所有的车都应该有基础的属性，比如车轮子，车身等基础属性。而车是不是又会有宝马，法拉利。我们可以吧宝马，法拉利看成是普通车子的继承，宝马法拉利有基本的车的属性，但是它又扩展了新的功能。我们可以这么想，继承是为了完善。
class Animal:
def eat(self):
print("-----吃----")
def drink(self):
print("-----喝----")
class Dog(Animal):
def bark(self):
print("----汪汪叫---")
这个就是对象的继承，Animal对象被Dog对象继承，狗是不是属于动物类，你要是说动物都会汪汪汪叫，这肯定不对，但是你说动物都会吃，都会喝，这不是动物的基本功能吗？而继承，则Dog对象自动继承了吃喝的功能，它自己又有个新的功能就是汪汪汪叫。随意要给他增加新的功能。
对象方法的重写
重写，只有继承了对象的对象，然后又定义了它的父类已经拥有的方法，才叫重写。
这里举不出什么好例子，我就不举了，嘻嘻。
私有属性与私有方法的在继承中的调用
私有的方法，继承的对象无法继承。而私有的属性，也无法直接访问，只能通过父类的方法调用来访问私有的对象属性
# -*- coding:utf-8 -*-
# author:ke_T
class A:
def __init__(self):
self.num1 = 100
self.__num2 = 200
def test1(self):
print("-----test1----")
def __test2(self):
print("-----test2----")
def test3(self):
self.__test2()
print(self.__num2)
def get_num2(self):
return self.__num2
class B(A):
def test4(self):
##self.__test2()
print(self.__num2)
b = B()
b.test4()
比如这个例子，当我想通过继承的对象调用父类的私有属性时，就报了错误。
多继承
多继承则是有多个父类，它有个很需要注意的点，看下面的案例
# -*- coding:utf-8 -*-
# author:ke_T
class Base(object):
def test(self):
print("----Base")
class A(Base):
def test(self):
print("-----A")
class B(Base):
def test(self):
print("-----B")
class C(A,B):
pass
#def test(self):
#
print("-----C")
c = C()
c.test()
print(C.__mro__)
打印结果：
-----A
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.Base'>, <class 'object'>).
__mro函数，打印一个元组，是继承对象方法调用的层次结构，，而这个顺序，就是看继承的时候的顺序，C（A,B），则如果C中没有重写的方法调用，则会顺着先到A，再到B，再到Base,最后到Object。当然，如果在C（B,A）则从B再到A。当然，在设计类的时候，要尽可能保证这些类中没有相同的方法。像这样子的形式，就是要调用B的test方法，那该怎么办？想想方法的重写的调用，就要在A中的test函数写上B.test(self),这样就实现调用了
类属性
类方法
类方法的格式，就需要写@classmethod,声明是类的方法，然后传参的命名是cls，这个是规范命名，当然，你也可以不这样子命名，不过会觉得你不专业。
静态方法，也需要标识，@staticmethod 另外，它可以不用传参。
总结，这次总结得挺乱的，因为知识的多，有点赶，就显得凌乱。当然，也是学到很多，同时心里有些浮躁，稳住，加油啦！
