小小总结，写得有些乱

Posted 2020-10-08

字符串：

字符串常用方法：

# -*- 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中的唯一的映射类型，它是无序的，因此像列表那样不能通过下标来访问，字典中的键是唯一的，值不唯一。特点：

1. 键与值用冒号:分开；
2. 2.项与项用逗号,分开
3. 字典的键必须唯一

 

访问字典的值：

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 另外，它可以不用传参。

 

 

  总结，这次总结得挺乱的，因为知识的多，有点赶，就显得凌乱。当然，也是学到很多，同时心里有些浮躁，稳住，加油啦！