python基础

  • python基础
                        • 　　　　　　　　　　　　　　　　　　　　
    • 字符串

       基本数据类型

       所有对象具备的功能都保存在相应的类(变量名.点后面调用功能类型(改变其性质)

      • int#数字
      • str#字符串
      • bool#布尔
      • list#列表
      • tuple#元组
      • dict#字典
    •  源码括号里如果有一个self表示不用传参数如果self后面有逗号隔开几个表示传几个参数
  •  1  s = "hello {},age {}"#s是变量名大括号里面是占位符随时可变可不填
    2
    3 • print(s)#打印s
    4
    5 •n1 = s.format('sasass',19)#s就是上面变量名,调用format(格式化占位符)然后写入变量值然后变量名n1
    6
    7 • print(n1
  • join连接字符串
        • 支持元组列表
        • 1 #join
2 li - ["asd",''ioio"]
3 s = "_".join(li)#s是变量名,join能把俩字符串连接起来 
4 print(s)

     

     

  • split是分割字符串
      • 1 s = "slcslcslc"
        2 ret = s.split("c",1#1找第几个)#如cs-cs-cs-cs可以以个字符串输入多个字符然后找分割号
        3 print(ret)

    •  

       

       

  • 字符串转换成int(整数)
    • 　　 
      1 lil = ["苹果","梨","橡胶","土豆"]
2 for key,t in enumerate(lil,1):   #enumerate自动生成序列,默认从零逗号后面能从1开始排列
3     print(key,t)
4 
5 inp = input("输入输入>>:")
6 
7 inp_num = int(inp)#字符串转换成int(数字)
8 print(lil[inp_num-1])#减一因为默认是从零打印,减一效果从1开始

       

       

       

  • %s是多个变量引用，如果是数字则%d
    • 　　

       

       

  •  三元运算符
    • 　 
      1 name = "aiao" if 1 == 1 else"edei"#name等于aiao若1等于1打印aiao否则打印edei
2 print(name)

       

       


       

  • 深浅拷贝
    • 　str(字符串),数字:　拷贝,复制地址都一样因为从新设置
    • 列表,字典浅拷贝都是复制第一层,底层没复制

    •  

       

  • 函数式编程
    • 　　1,def定义函数xx():#xx函数名
      •       　　2,打印
    •       3,写出函数名(等于打印)
    • 函数后面加括号表示执行该函数
            • 1 def sms():#def定义sms函数名
2     print("aiao")#要打印内容放在sms内存里
                    return#不加会返回None它可以赋值(返回数值)可定义是否成功
3 sms()#调出打印


               

      • 函数返回值
        • 　　 
          def email():
    if True#如果是真返回真
        return True
    else:#否者返回假
        return False

ret =  email()

if ret:
    pront("aiao")
else:
    print("eded")

           

    • 　　
    • 1 def kuai(p):#p形参(变量名)
2     print(p)#打印形参
3     return True#返回真
4 ret = kuai("aiao")#aiao变量值(赋值)实际参数,ret变量名好调用
5 if ret:#如果ret是真返回ok
6     print("ok")

       

       

       

    • 　　1,动态参数形参加星号(*)
        • 　　　　一般一个星用args,俩星用kwargs
      • def f1(*a):#星号代表可多传参数(动态参数)(相当于元组)
            #a = (123,)
            #a = (123,5567,)#相当于a里面可以传任何参数,逗号分隔
    print(a,)
f1(123,5567,"ghf",879.000)

        2,动态参数俩星号代表字典,传参数必须两个
        　　

        def f1(**a):
    print(a,)
f1(k1=123,k2=456)

        3,混合型动态参数

        • 　　 
          def f1(*args,**kwargs):
    print(a,)
    print(aa)
f1(11,22,3, k1=123,k2=456)

           

           

           

           

      • 　　全局变量就是在外面创建个变量,局部变量就是在函数内创建的变量,局部不能改变全局
        • 　　 
          1 PERSON = "aiao"#全局变量#全局变量都要大写
2 
3 def func1():#func1是函数名
4     a = 123#局部变量
5     global PERSON#能改变全局变量的关键字    
6     print(a)#打印输出的是a的变量值
7             #如果不修改变量想读谁就可以,要想改变全局要加global再加全局变量名

           

           

           

  • random随机验证码
    • 　　 
      import random#导入模块random
temp = ''#temp空字符串
for i in range(6):#首先循环随机码几个位置
    num = random.randrange(0,4)#num（是英语，在..里面）在第几个位置随机（位置1或3产生随机）
    if num ==2  or num ==5:#如果位置随机到了2或5就循环下面的1到10数字
        rad2 = random.randrange(10)#随机产生1到10间的数字
        temp += str(rad2)#空字符串加上随机产生的数字，str是把数字和字母揉一块
    else:#否则循环字母
        rad1 = random.randrange(65,91)#随机产生数字65和91之间，因为65到91是ASCII码对应的26个字母
        c1 = chr(rad1)#chr把随机产生的数字变成字母（chr是数字转字母的转换器）c1是变量名
        temp += c1#temp空字符串加上随机字母打印出来
print(temp)

       

  • eval和exec可以执行字符串形式的代码的表达式
    • 　　 
       1 ret = eval("102+898+22+12")#eval能把字符串里的数字相加
 2 print(ret)
 3 
 4 
 5 ret = eval("a + 90",{"a":99})#也能用子典a就是key调用99加90
 6 print(ret)
 7 
 8 
 9 #exec("for i in range(10):print(i)")#exec执行一段代码
10 eval,表达式,有返回值
11 exec,执行代码,没有返回值
      View Code

       

  • filter是过滤器
    • 　　 
      1 def f1(x):#定义函数f1
2     return#啥也不反回相当于站位,不写报错
3 
4 ret = filter(lambda x: x>22,[11,22,33,44,5,5,6])#ret变量名,filter把要过滤的括起来lambda是简单函数表达式自动返回大于22
5 for i in ret:#循环列表
6     print(i)
      View Code

       

  • open文件读取写入追加等
    • 　　 
       1 #只读
 2 f = open("ha1.log",'r')#open是打开文件,ha1.log是文件名,后面可以写入,读取和追加,等
 3 f.close()
 4 
 5 #只写,把原来的删除
 6 f = open("ha1.log",'w')
 7 f.write("123qwe")
 8 f.close()
 9 
10 #只写不可读,不存在创建,存在则报错
11 # x = open("ha1.log",'x')
12 # x.close()
13 
14 #追加,可读,不存在则创建,存在则从后面新加上内容
15 a = open("ha1.log",'a')
16 a.write("abcd")
17 a.close()
      View Code

       

    • f.tell()#获取指针位置
    • f.seek()#调整指针的位置(跳转到某个位置)
    • f.write('xxx')#写入
    • f.read('xxx')#读取,不加read是读取全部,加了之后可写第几个1或几
  • 装饰器
    • 　　装饰器就是用@加薪函数名替换下面函数并且能执行新的和原来的函数,薪的函数可以写模型让下面旧函数调用
      • 　　f2#装饰器函数 = outer#调用(f1#原函数)#上面函数(装饰器)会把原函数覆盖掉
  • 正则表达式re模块
    • re.match()#从头匹配
    • re.search()#浏览全部字符串,匹配第一个符合规范的字符串
    • re.findall()#将匹配到的所有内容都放在一个列表中
    • re.split#分割
    • re.sub()
    • findall函数就是把匹配的字符在字符串列表或元组里全都找出
    • .(一个点)代表能把字符里隔着一位也能找出来,隔两个不可以.
    • ^(尖椒符)要找的字符必须在前头才能找到,,,,非的意思,非[1-9]其他都匹配(就是把不是中括号内的匹配)
    • $(到了福)必须在最后
    • *是贪婪匹配,从0到多个匹配
    • +是一到多个,没有匹配不出来
    • ?零到一个
    • {}自定义匹配,大括号写位置
    • []中括号是或者
    • -小杠1至9,或a到z,就是那到那
    • 反斜杠
    • \d匹配任意十进制数,类似于类[0-9]
    • \D匹配任何非数字字符,相当于类[^0-9]
    • \s匹配任何空白字符相当于类[\t\n\r\v\f]匹配空白字符
    • \S匹配任何非空白字符,相当于类[^\t\n\r\f\v]匹配不是空白字符
    • \w匹配任何字母数字字符,相当于[A-a-z-Z,0-9_]
    • \W匹配任何非字母数字字符,
    • \b匹配一个单词边界,也就是单词和空格间的位置
  • 模块
    • 　　os.path#寻找路径
    •      os.path.dirname#寻找上层目录
    • urllib模块
      import urllib
from urllib import request

f = request.urlopen('http://www.jd.com/')#打开网页
request = f.read().decode("utf-8")
print(request)
      

       
      

       
      

      • 

    • json模块是不同语言或程序之间数据交换的协议

        

      • 　json.loads用于将 字典,列表,元组,(里面元素必须是双引号)形式的字符串,装换成(python的数据类型)相应的字典,列表,元组　
        • 

      • json.dumps()#将python的基本数据类型转换成字符串

          

        • 　　

          

          1 user_list = ["alex","eric","tom"]
2 import json
3 s = json.dumps(eser_list)#dumps转换
4 print(s,type(s))#type(类型)
          

          

           
          

          • 

        

        • 

      

      • 

    • import requests

        

      • 　　

        

        1 import requests
2 
3 response = requests.get("http://www.jd.com")
4 response.encoding = "utf-8"#内部转编码
5 result = response.text#text表示返回内容
6 print(result)
        

        

         
        

        • 

      

      • 

    • XML也是不同语言之间的数据交换的协议
      • 

        

      • 利用ElementTree.XML将字符串解析成xml对象　

        

        1 from xml.etree import ElementTree as ET#导入xml里面的ET模块(ET 是ElementTree别名)
2 
3 #打开文件,读取xml内容
4 str_xml = open('xo.xml','r').read()
5 #将字符串解析成xml特殊对象,root代指xml文件的根节点
6 root = ET.XML(str_xml)
        

        


         
        




        • 

      • tag获取当前节点的标签名
        • 

      • attrib = None#当前节点的属性
        • 

      • text = None#当前节点的内容
        • 




      




    

  • 

      

    • 　　shutil高级的文件,文件夹,压缩包处理模块
      • 




    




    • 

  • 反射

      

    • 　　就是通过字符串的形式,导入模块
      • 

    • 通过字符串的形式,去模块中寻找指定的函数,或全局变量,并执行
      • 

    • getattr(commons,"f1")#反射,传入的第一个是导入的模块,f1:就是要去模块里面找一个叫f1的函数名字,根据字符串的形式找,如果没找到可以加个默认值,None
      • 

    • 

        

      • 

        

        1 inp = input("请输入:")
2 inp_func = input("请输入要执行的函数:")
3 dd = __import__(inp)#__import__以字符串的形式导入模块
4 target_func = getattr(dd,inp_func)#以字符串的形式去某个模块中寻找函数名
5 result = target_func()#target_func获取到的函数名后面加()表示,执行函数
6 print(result)
        

        

         
        

        • 

      • hasattr(Commons,'aiao')#hasattr判断模块里存不存在xx函数名,如存在返回True
        • 

      • setattr(commons,"aiao",18)#变量名aiao,变量值18,在内存里为哪个模块函数创建一个全局变量/函数
        • 

      • delattr#删除模块里某个函数/变量
        • 

      

      • 

    • 扩展点:

        

      • 　　import模块

          

        • 　　a = __import__("模块名")#a等于用import导入模块名
          • 

        • a = __import__('lib.test.com',fromlist=True)#fromlist等于去某个列表找函数模块名,不加fromlist只找到目录
          • 

        

        • 

      

      • 

    

    • 

  • 面向对象
    • 

      

    • 　　首先定义类
      • 

        

      • 　　class 类名:
        • 

          

        • 　　def 方法1(self,xxx)#不加参数自动有self,要加参数self,逗号分开写上参数

            

          • 　　pass
            • 

          

          • 

        • 根据类创建对象,也叫实例
          • 

        • 使用对象去执行类中的方法
          • 

        

      • 　类名后面加括号就是自动执行类中的__init__方法;创建一个对像也就是实例

          

        • 　　在__init__方法中执行具体封装的操作,__init__叫构造方法,也叫构造函数
          • 

        

        • 

      

    • self是形参数,Python内部传递,  谁执行代指哪个函数
      • 

    • 

        

      • 　　obj = FOO()
        • 

      •       obj.fetch('aa') #等于self=obj对象(实例),backend="aa"

          

        • 　　

          

          封装
          1           class oldboy:
2     def fetch(self):
3         print(self.backend)
4     def add_record(self,backen):
5         pass
6 
7 obj = oldboy()
8 obj.backend = "aaaaaaaaazzzz"#等于self.backend(封装)
9 obj.fetch()#调用方法
          

          

           
          

          • 

        

        • 

      

      • 

    • 继承

        

      • 　　派生类(子类)可以继承基类(父类)中所有得功能
        • 

      • 派生类和基类中同时存在,优先找派生类
        • 

      • 可以继承多个基类优先级是先左后右
        • 

      • super(当前类,self).__init__()
        • 

      

      • 

    • 多继承

        

      • 　　
        • 

      

      • 

    

      

    • 

    • 面向对象进阶
      • 

    • 　@staticmethod

        

      • 　　#只要加上就是静态方法,然后没有self,不需要创建对象,就类似把一个函数放到类里面,(静态方法存在的意义,不需要创建对象就能调用)和对象没关系 
        • 

      

        

      • @classmethod#类方法,函数里面必须有个cls参数
        • 

      • 

      • 　　#通过类访问的:静态字段,静态方法
        • 

      •       #通过对象访问:普通字段,类的方法
        • 

      • 成员修饰符

          

        • 　　面向对象中一些常用的特殊方法,__init__,__call__,__delitem__
          • 

        

        • 

      • @Provice#加上之后就叫特性,特点是访问时将方法伪造成一种字段

          

        • 　　

          

          1 @property
2 def end(self):
3     
4         temp = "moumou"srlf.name
5         return temp
          

          

           
          

          • 

        

        • 

      • 总结成员:

          

        • 　 字段     静态字段(每个对象都有一份),  普通字段(每个对象都不同的数据)
          • 

        •     方法     静态方法 (无需使用对象封装的内容),  类的方法),普通方法(使用对象中的数据)
          • 

        •     特性     普通特性(将方法伪造成字段,后面不用加括号)
          • 

        • 快速判断,是类执行还是对象执行

            

          • 　　有self是对象调用
            • 

          •       无self是类调用
            • 

          

          • 

        

        • 

        • 

      • 成员修饰符

          

        • 　　除了自己,谁都不行
          • 

        • __俩下划线代表私有
          • 

        

        • 

      • 异常处理

          

        • 　　

          

          1 try:
2     xxx
3 except Execption as e:
4         print(e)
          

          

           
          

          • 

        

        • 

      

      • 

    • 所有的是咧中封装的内容相同时,用单例模式
      • 

    







            

            
posted @ 
2017-06-04 13:29 
自习室 
阅读(190) 
评论(0) 
编辑 
收藏 
举报