pyhton基础入门的个人学习笔记

help("str") #字符串帮助文档
type(a) #可以查看数据类型
id(a) #可以查看唯一标识符
len(a) #查看长度
dir(a) #类型方法，查看该类型支持那些操作(方法)
bin(1)    

#1.编码
#coding=utf-8
a.decode('utf-8') #转换为utf-8
a=u"字符串" #转换为unicode

#2.类型
list #列表 a=[ 1,23,3]
tuple #元组 a=(1,2,2,3,45)
dict #字典 a={0:1,1:1}
#不可变类型：int,string,tuple #不可变:不能在原有的内存中修改,修改会生成新的对象
#可变类型：list,dict    #可变:会在原有的内存中修改，并且当把它赋予给其他变量，俩个变量都会指向同一内存地址

#3.转义
print 'abcd\'' #打印出'
print r'abcd\n' #\n换行,前面加上r可以打印出\n

#4.字符串
a='abcde'
a[leng(a)-1] #字符串最后一个子串
a[-1] #同上
a[0:] #从第0位开始后面所有得到子串
a[0:1] #得到'a'
a[1:3] #得到'bc'
a[2:4] #得到'cd'
a[:-1] #到最后一个的前面所有'abcd'

a.replace('a', 'A') #会把a字符串里的a换成A得到一个新的字符串，打印'Abcde'
a.find('c') #会查找有没有c这个子串，有的话会输出第一次出现的下标位置，没有的话输出-1
a.find('c',2) #可选参数2是以字符串从2下标开始后面出现c得下标位置
'hehe is {1} {0}'.format('A','B') #和占位符一样，但是可以随便填写然后根据下标填写占位
'hehe is {b} {a}'.format(a='A',b='B')#也可以键值对的方式占位 


#占位符加入字符串
print 'hahah ni %s hao' % 'hen' #使用%s字符串占位符加入字符串
print 'hahah ni %d hao' % 1 #使用%d数字占位符加入字符串
print 'hahah ni %s hao %s' % ("使用","呵呵") #使用元组的方式插入多个占位符字符串
print 'hahah ni %(a)s hao %(b)s' % {'a':"使用",'b':"呵呵"} #使用字典键值对方式
#字符串拼接
",".join([a,b,c]) #会打印以','号分割输出的三个字符串


#打开文件读取内容。#文件前加入r小尾巴是以最原始读取参数中的字符串
d=open(r'a.txt','w')  #打开文件,第二个参数有三种模式w为write写入,r为read读取,a为append尾行添加
d.write(r'hi \n 你好。') #写入内容
print >> d,"sssss"    #以print方式来写入内容，>>为重定向
d.close            #保存关闭文件
d=open(r'a.txt','r')    #读取
print d.readline()    #写多行这个代码会以游标的方式把文本的内容一行一行的打印下去   
d.seek(0)         #游标会到起始位置
print d.read(1000)      #设置为1000是因为能足够把文本里的全部内容打印出来  
#with方式打开读取内容
with open('a.txt','a') as c:    #使用with的方式不需要打开后关闭文件，因为自动关闭，上面的方式打开后必须关闭
    c.write('xixixi')    #前面为四个空格缩进



#使用文件读取的python的linecache标准库读取文件内容
help(linecache) #帮助文档
print linecache.getline("a.txt",1) #读取一行，第二个参数设置想读取的哪一行
print linecache.getlines("a.txt") #读取每一行然后用list列表装起来


#5.列表
#特点：（有序的集合，通过偏移来索引从而读取数据，支持嵌套，可变的类型）
#创建列表：[],list()
a=[1,2,3]
b=a[:]        #这个把列表a拷贝给b，此时用id()查看a和b地址是不一样，因为重新生产了一个对象 
a=[[1,2,3],[5,7,8]] #列表支持嵌套
a[0][1]=11  #列表中的第一个列表的第一个值修改为11
#列表索引
a=[1,2,3,4,5,6,7]
a[0:4:1] #正向索引(从0的位置到4，步长为1)，取值为:1234
a[-1:-4:-1] #反向索引(从反方向取值:765,步长为反方向1)
a[1::2]  #默认索引(从1的位置到后面所有，步长为2，取值246)
#列表添加
a=[1,2,3]
b=[8,6,7]
"+"号生成一个新的列表
a.extend(b) #在原有的a列表上面把b的列表值添加进去
a.Append(12) #在此列表添加任意对象在末端，比如插入12数值
a.Insert(1,'ab') #在次列表任意位置添加任意对象，比如下标1位置插入'ab'
#列表的修改
a[1]='ni' #把下标为1的值修改为字符串'ni'
#列表的删除
del a[0] #把第一个下标值删除
a.remove(3)  #在列表中删除值为3的值，如果有重复的则删除第一次匹配到的值，如果删除的值不存在会抛出异常
a.pop()   #会返回列表的最后的一个下标的值并且删除
#列表的成员关系
a=[1,2,3]
2 in a    #判断2是否在列表a里面，此处返回True
5 in a  #返回False
5 not in a  #判断5是否不是在列表a里面，此处返回True

#列表推导式


[expr for iter_var in iterable] #首先迭代iterable里所有内容，每一次迭代，都把iterable里相应内容放到iter_var中，再在表达式中应用该iter_var的内容.
[x for x in range(1,11,2)] #range(1,11,2)方法生成一个1到10的列表,步长为2,然后得到1,3,5,7,9的一个列表，不写默认为1
[x for x in range(1,11) if x % 2 == 1] #这个判断和上面写步长是一个效果，然后生成列表

#列表的排序翻转
a=[33,11,22,44]
b=a.sort()  #sort()方法原地就进行了修改，也就是排序,而且没有把值赋予给b
if b is None       #表示该值是一个空对象,空值是Python里一个特殊的值，用None表示
    print("hehe")  
print a     #通过sort()方法排序，这里结果是[11,22,33,44]
a.reverse()  #reverse()方法翻转了列表，得到[44,33,22,11]

#内置list方法
a="asd"
list(a)   #打印出[a,s,d],把该字符串返回成一个列表
list((2,3)) #打印[2,3],把元组也给返回成了一个列表
list(12)   #出错，数字是不可迭代对象所以不能返回成为一个列表

#xrange和range的区别
a=xrange(1,10) #生成数值为1到9的列表。此方法生成一个xrange对象
print a   #结果打印xrange(1,10)这么一串没有变化
a[0]      #结果打印数值1，所以说不影响取值
b=range(1,10) #也是生成数值为1到9的列表。
print b   #结果直接打印出[1,2...9]的列表

#在数据量非常大内存吃紧的时候使用xrange()方法，此方法一般用于循环里，比如只需要对部分数据进行操作，而不需要得到全部数据来操作数据的时候可以使用xrange来节省性能
["this %s" % d for d in xrange(10)] #通过xrange()方法得到列表放入d中，再把d中的值通过占位符的方式循环放入前面的表达式中。
#打印结果为['the 0','the 1',....]一直到9的一个列表
[(x,y) for x in range(2) for y in range(2)]
#打印结果为[(0,0),(0,1),(1,0),(1,1)],双重for循环的值放入表达式中的元组当中，最终返回列表
dict([(x,y) for x in range(2) for y in range(2)]) #dict()方法把上面的列表转为字典
#结果为{0:1,1:1},为什么只有两个值？因为两个0是相同键，所以覆盖了

#列表的再议删除
a=[1,2,3]
b=a         #用id()方法查看a和b是指向同一地址的
del b        #删除b后，a还是有值，因为此时该值由a来引用
del b[:]    #清空b后，此时b为[]空值，来看a，结果a也被清空了



#6.元组
#特点：有序的集合，通过偏移来读取数据，属于不可比类型,不能原地修改,没有排序,修改等操作
a=(1,2,3)
a[1:3]   #也能通过这样取值
b=list(a) #把a元组转换成list赋值给b
b[0]=5   #把列表b的第一个值修改为5
a= tuple(b) #然后把列表b转换为元组赋予a，此时a生产一个新的对象(5,2,3)


#7.集合
#特点：没有顺序的概念，所以不能切片和索引操作
#创建集合：可变:set(),不可变：frozenset()
b = set("abc")   #结果为set(['a','b','c'])
b.add('py')   #add()方法插入结果:set(['a','c','py','b'])插入整个
b.update('py') #update()方法插入结果:set(['a','c','p','y','b'])插入单个
b.remove('a') #删除集合里的'a'
'c' in b   #返回true；可以使用in 和 not in

#交集，并集，差集
c=set('abcd')
d=set('bcdef')
c & d       #结果:set(['b','c','d']),交集:取相同的
c | d          #结果:set(['a','b','c','d','e','f']),并集:合并集合
c - d         #结果:set(['a']),差集:c集合中只有'a'没有在d集合中出现
#去重复
a=[1,2,3]
a.append(1)   #末尾添加数值1，在列表中重复了[1,2,3,1]
set(a)          #结果为set([1,2,3])，通过集合去掉了重复
list(set(a))  #再把集合转为集合
#frozenset()    #此集合不可变，不能进行add添加和删除的操作


#8.字典
#特点：字典是无序的，不能通过偏移来存取，只能通过键来存取
#创建字典：{},dict()
info = {'a':1,'b':2}     #定义一个字典
info['a']    #通过键值对取得值1
binfo = {'a':[1,2,3],'b':[4,5,6]} #定义一个值为集合的字典
binfo['a'][2]=5        #如果我要修改第一个健里的第二个值，可通过这样修改
xinfo = {('a','b'):1,('c','d'):3} #键可以是数值，字符串，元组等其他不可变对象，键为元组时，键里面的元组值不能是可变的对象
#添加字典
ainfo ={'name':'ab','age':20}    
ainfo['xx']=30        #写一个字典里面没有的键就可以添加进去
#修改字典
ainfo['name']='ss'    #也是一个通过赋值的操作修改字典里面有此健的值
#字典的update操作
ainfo.update({'aa':6,'name':'bb'})  #这个方法会把里面没有的键值添加进去，有键相同的话会覆盖里面的值，就是修改
#字典的删除操作
del ainfo['name']  #删除键值
del ainfo    #直接删除ainfo这个字典变量
ainfo.clear()     #使用该方法清空字典
ainfo.pop('name')    #返回该键的值并删除该键值
ainfo.pop('s','aa')    #字典的pop方法里如果填入没有的键，再在第二个参数里填入默认值的话会返回默认值，列表的pop方法没有此项功能
'name' in ainfo     #通过in判断键是否在字典里，返回true，使用not in相反
ainfo.has_key('name')    #通过has_key()方法也可以判断该键是否在字典里面
ainfo.keys()    #返回一个列表，里面是该字典的所有键
ainfo.values()    #返回一个列表，里面是该字典的所有值
ainfo.items()    #生成一个字典的容器
#结果:[('name','ab'),('age':20)] #返回一个列表，并把该字典里的每一对键值都生成为一个元组
ainfo.get('name') #也可以得到该字典对应的键的值
ainfo.get('aa','c')  #该字典中没有此健会返回一个NoneType类型，也就是空类型，写入第二个参数默认值的话，会返回此值



#9.逻辑判断与循环
#if判断
if True :   #条件
    print 4  #执行代码块，前面为四个空格缩进

例如：
a=1
if a :
   print 5 #a有值且在int类型下不为0，所以if判断为true,执行代码块

#----分割线-----
if a and b #and就是并且，而且要全部为真时才会执行里面的代码块
if a or b  #or或者，满足其中一个
if a == b    #==判断两边值是否相等
if a is b    #is判断两边变量是否拥有同一地址
if 'a' in a   #判断字符串'a'是否在变量a中，有的话返回真，not in 就是不在则返回真
if not a     #反转，不是假的返回真
if True :
    print 'true'
else:
    print 'false'
#if如果真我就执行下面true代码，else否则我就执行false这段代码

#elif用法
a='abcd'
if not a :
    print 'true'
elif 'v' in a:              #全称为else if
    print 'v'
elif 'd' in a:
    print 'd'
else:
    print 'false'
#最后打印'd'
#三元表达式(和其他语言不太一样)
4 if True else 3  #如果表达式为真打印4，else否则打印3
[4,3][True]    #如果表达式为真打印3，[]里面第一个为真，第二个为假


#while循环
x = 1
while x<20 :   
    x +=1     #前面为四个空格缩进 ,x每循环一次加1，自增1  
    if x>20:
    #continue #如果是continue跳出此次循环,将不执行下面语句而是进入下一次循环
    print x
        break  #break跳出整个循环
else:        #整个循环结束后执行else语句块
    print 'a'  #如果是continue的话执行完的话会执行else语句，break则是跳出整个循环所以不会执行else语句



#for循环
for x in 'a,b,c,haha'.split(','):    #通过字符串里的,号把字符串分割生成一个列表
    print x,            #循环打印
else:        #和while循环一样循环完执行,循环中有continue会执行，break不会执行
    print x    #for循环此处的x会拿到循环完后的最后一个迭代值，这里会打印haha

#有趣的or
a=0        
b= a or None    #a为int类型但是为0值，所以b会被赋值None
print b 




#10.语句与数据结构的应用
a='abcde'
for i in a
    print i  #会把字符串每个子串都循环迭代出来，列表，元组都可以
#迭代字典
a={'a':1.'b':2,'c':3,'d':4}
for i in a.keys():    #得到所有键返回一个列表并且循环打印出来
    print i
          
for x,y in a.items():
    print x,y        #用items方式把字典的键值生成为元组并返回成列表的形式打印键值 

#字典排序
a={'e':1.'b':2,'c':3,'d':4}
x=a.keys()        #获取字典所有键生成为列表
x.sort()        #给列表里获取的所有健进行排序
for i in x:
    print i,a[i]    #打印排序后的键值

#排序的sorted()方法
a="dase2AdU1"
sorted(a)    #该方法对字符串里的每个子串排序并且返回一个列表，排序方式为:数字，大写，小写
sorted(a,reverse=True)    #上面是从低到高，这里是从高到低排序

#翻译表
#maketrans和translate的使用
import string       #引入string块
g=string.maketrans('123','abc')  #把1，2，3相对翻译成a,b,c。是一个个翻译的
a='12345'    
print a.translate(g)    #会把字符串翻译成想要的样子，打印abc45
a.translate(g,'45')    #第二个参数是把字符串中的45的字符给删除掉，是一个一个删除的，先把字符4删掉，再把字符5删掉




#11.函数
#定义一个有参数函数（方法），使用的时候调用这个方法名就可以了
def a(a,b,c):    #定义了一个方法而且给方法定义了a,b,c三个参数，可以没有参数
    "哈哈哈"    #方法的文档注释
    return "12"
#执行：print a(1,2,3)  传入参数执行该方法，得到返回值
#使用：a._doc_    #查看该方法文档

#定义一个可选参数的函数
def a(a=4)
    return a
#执行 print a(a=5)    #这里你这个参数可以不写它会默认值为4，我传给它一个5


#全局变量和局部变量
b=3        #全局变量
def a():
    #global b    #这里如果我确实要用全局变量b并往下修改成4，那么我可以用这种方式把全局变量拉进方法体内进行修改
    b=4        #局部变量
    return b

def c():
    return b

print a()    #函数a返回b，为自己的局部变量
print c()    #函数c也返回b，但是自己没有局部变量b，所以返回的是全局变量b

#参数为字典和元组
def a(**kr):    #**代表字典，*代表元组，这种参数也是可选参数，选填
    return kr

#print a(a=4,c=3) #以这种方式传入给函数参数里声明的字典返回的是字典形式的键对值
#print a(1,34,5)  #参数为一个*时为元组，此时这里传入的参数全是元组值

#参数的可选和不可选
def a(a,b,c,d,*z,**kr):
    return z,kr      #可以返回多个，返回生成元组

print a(1,2,3,4,67,[1,2,3],g=1,e=9)
      #不可选参数为abcd会依次传入1234，*z元组会传入(67,[1,2,3]),后面=号方式传入的会给予**kr字典，是有顺序的
      #后面=号方式传入的比如g，在函数参数中定义的变量不能同名，也就是说这里传入的g在定义函数参数那里也不能有g




#12.面向对象
#定义一个class和其内部的函数
class test(object)
    def __init__(self,a):
    self.a=a    #class中的第一个参数self是内置的不能去除，必须定义

    def get(self,a):    
        return a
#self相当于class本身，self.a是全局参数，a是方法参数，这里相当于get,set方法
#t=test()，t相当于test的一个实例

#继承
class base(object):
    def __init__(self,name):    #构造方法
    self.name=name

class b(base)    #继承父类base 
    def get_name(self):
    return self.name





#13模块
import a    #调用a.py文件，可以调用里面的所有函数方法，该文件是一个模块
a.getname()    #使用import方式调用a模块里的方法

from a import getname    #使用这种方式就可以直接用该模块方法,getname也可以是*,代表该模块下所有的方法都可以直接调用
getname()    #直接使用

if __name__ == "main":        #在该代码块里写的代码在本身模块里运行，而不被其他模块调用
__all__=["getname","getline"]   #模块变量可以限制哪些函数可以用，
                #列表里面的字符串是函数名，没有写进的函数，就算import *也是调用不出来的
                #这种方式相当于把某些函数方法公开的 方式，没有写进的方法相当于私有的


#调用包下面的模块
import m2.a as a    #m2代表包,a是m2下的模块，as后面的a是给前面引用的模块取了个别名
from m2 import a    #使用这种方式也是可以的，a模块下的方法也是直接使用
from m2.a import getname   #这种方式同上，import *可以调用里面所有公开的方法

#包下面的__init__.py
__all__=['a','b']   #这里代表m2下面a模块可以被调用，是公开的
from m2 import *    #import *时必须在上面定义了哪些能使用
print a.getname()   #具体调用

 

转载于:https://www.cnblogs.com/EzioSyh/p/6916378.html