小小总结,写得有些乱

字符串:

字符串常用方法:

# -*- 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指向keyv指向了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 另外,它可以不用传参。

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

时间: 2024-11-07 17:01:43

小小总结,写得有些乱的相关文章

struts2框架(整体写的比较乱之后有时间了在补)

Struts2框架 struts2核心就是拦截器 第一个sturts2练习 继承ActionSupport类 写方法UseLogin Public class UserAction extends Actionsupport{ Public String UserLogin(){ Return SUCCESS; } } 4.在classpath(src)路径下面写出一个struts.xml文件 <struts> <package> <action name=”userLogi

杂记--写于狂风乱作的夜晚

一个不小心就2015年了,一个不小心我就要大学毕业了,虽然我已经实习了大半年了,但是现在想想我只能说时间过得很快.这段实习期间我感觉我变换很大,由一个学校内的人变成了学校外的人,由一个消费者变成一个生产者,我切切实实的体会到了生活的不容易,但是生活就是这样,用事实让你记住生活的不容易,然后让你去珍惜现在拥有的,以及让你去努力获得你想拥有的. 前一段时间我满脑子里就只剩下“钱”这个字眼了,我以前不是这样的,我以前觉得钱不是很那么重要,觉得生活平平淡淡就好.但是人年纪越大懂得事情也越多,为什么自己不

总是要总结一年的工作(写给自己和想要从技术创业开公司的朋友们)

2014年就要结束了,自己检讨自己培训系列文章食言! 然后感叹一下,总要总结一下今年的工作,为下一年做个计划,思考一下自己的不足. 2014年对我来说是个繁忙的一年,年中正式从兼职公司辞职,全力经营自己注册的公司. 我想以个人的经历给想辞职创业的朋友一点鲜活实例,作为教材-正面也罢反面也罢,您能有所收货即可. 2010年的年中裸辞后(很冒险的方式),注册公司,注册的是那种10万的小公司,我发现,原来旧公司的客户表达的支持意向,全都不是那么回事了.将近1年时间,1分钱没挣到的我,换了个方式回到了旧

C语言在VS2017环境下写俄罗斯方块的感悟

C语言给几乎所有人的印象就是语法太严格.使用太拘谨,错误特别多,纠结太细致.很难提起兴趣来.同时还有如下的巨大弱势: 1:C语言写了很久还是只开发黑窗口程序,看不到实际应用在哪里,严重打击兴趣: 2:如果想要使用高效的集成开发环境,却很难和图形库链接上(主要是太多横空出世.突如其来的.不懂的操作细节,比如链接Lib库,为什么要那样做?不清楚,只是照着做而已):以至于高效IDE的魅力也大大失去了光彩. 3:硬要写图形化窗口你可能还真得跑到TC这种连复制粘贴都不友好的环境下去玩.实际公司中不用这低级

帮朋友写的,鲁智深吃馒头, 没装vs, 还没有亲测

//定义一个一维数组并赋值int hes[100] ;for(int i=0;i<100;i++){ Hes[i]=i+1;}//不确定循环多少回,把循环写死了for(int j=0;j<100,j++){ int count = 0;//数不为零进入循环的个数 int countZero = 0;//数为零的个数,也就是删除了多少个 //过滤掉为零的(被删除了的) if(hes[j]!=0){ count++; //数到五,计数器重置,对应的和尚为零(删除) if(count==5){ co

swift __1 试写第一个swift程序

参照:http://swiftist.org/topics/96?page=2#comments 发现有几个地方一直报错,自己修改了下,有可能是xcode6更新导致 代码写的比较乱,这是我的硬伤,这次注释还是后面加上的,这也是我的硬伤,需要改.养成良好的代码习惯. 下面贴上自己的代码 // // ViewController.swift // SwiftCounter // // Created by 三十一 on 14-8-20. // Copyright (c) 2014年 yetuoxun

写给十年后的自己的信

十年后的我: 你好! 第一次这样称呼很不舒服!当然,现在写信的人是我,以后收到这封信的人同时也是我.感觉好奇怪,貌似我穿越了时空. 还是直接点题吧!我之所以会给你写这封信,是因为我希望自己在十年之后能够拥有一个很美好的未来.当然,那时的你已经知道我十年后是什么样子了.我是不是还倔强地在嘴角留着那一撇小胡子,当别人劝我刮掉的时候,我是不是还会执着地说想要把它留成圣诞老人的样子?你的身体有没有和我现在见到的大多数中年人一样发福,告诉我当你低头往下看的时候,是看到了自己的脚尖还是看到了自己的肚脐眼?我

哇 好久不写C 忘得差不多

为了得到一个数的"相反数",我们将这个数的数字顺序颠倒,然后再加上原先的数得到"相反数".例如,为了得到1325的"相反数",首先我们将该数的数字顺序颠倒,我们得到5231,之后再加上原先的数,我们得到5231+1325=6556.如果颠倒之后的数字有前缀零,前缀零将会被忽略.例如n = 100, 颠倒之后是1. 输入描述: 输入包括一个整数n,(1 ≤ n ≤ 10^5) 输出描述: 输出一个整数,表示n的相反数 输入例子1: 1325 输出例

[随笔]在清明节假期独自思考

有时候我们总是以为外界环境错了,其实错在内心. 这个假期有幸能一个人独自在学校,在宿舍,一个人的生活,能让我把精力更多的放在精神层面.所以有时候会不吃饭:) 1.思考了自己与外界的关系 之前有个名词"社会主义巨婴",老是自诩见多识广,最终也栽在了这个词上.无法处理好与外界的关系是巨婴的一个特点,一个人为中心,没有一定的组织能力,"好吃懒做",表里不一--没想到另一个我如此不堪,好像恰好占到了我最讨厌的所有性格. 我也有要守护的东西,但这种守护的信念还不够强大,其实也