python基础学习

一、基础问题

    输入中文乱码问题解决方案：
    方法1:在第一行或者第二行输入  #coding:utf-8
    方法2:在第一行或者第二行输入   # -*-coding:utf-8 -*-
    方法3: 在第一行或者第二行输入  # vim: set fileencoding:utf-8  

  

   BIF：

   查看BIF（python内置函数）：dir(__builtins__)

   每个BIF如何使用：help(int)

   获取类中属性、方法不包含魔术方法：

类.__dict__

   数据类型：

          1、字符串
2、数字 

2.1整型

2.2浮点

2.3布尔

2.4复数

3、列表
4、元组

 5、集合

  6、字典

  7、日期

http://www.runoob.com/python3/python3-data-type.html

     三元操作符：python三木操作符跟其他语言写法不一样，但是原理一样， x = x if x < y else y    //php中：x = x < y ? x : y

     断言assert，自爆：assert  x< 5    ,如果x真的小于5 ，会抛出AssertionError异常否i则忽略向下执行

    

二、有序列表
list 创建后可以修改
list = ['11','22','33']
list.append('55') //在结尾插入
list.extend([1,2,3,4]);//['11','22','33',2,3,4]
list.insert(0,'000') //第一个参数索引，第二个参数值
list.pop() //弹出最后一个,返回弹出的值
list.pop(index)//index索引，删除索引上的一个，返回弹出的值
del list[0] //删除list第0个,不返回弹出的值
list.remove('11');//删除list中第一个value为11的元素
list[2] = '99' //直接对索引值赋值就替换原索引上的值
list.count('11');//11在list出现几次
list.reverse();//翻转
list.sort();//排序,正序
list.sort(reverse=True) //倒序

【注】：list1 = [1,2,3,4]

list2 = list1

list3 = list1[:]

list1.reverse()

print(list1) //4,3,2,1

print(list2) //4,3,2,1直接等于的他的引用指向指向的是list1，没有重新在内存生成，所以1变2也变

print(list3)//1,2,3,4             分片的会重新在内存中生成一份，类似字符串

list4 = [11,22,33,11,22]

list4.index(11)    //0,默认只返回第一个出现的位置

lsit4.index(11,1,4)  //3 , 第一个参数是搜索的字符，第二个参数是起始搜索位置，第三个参数是终止搜索位置

截断字符串与数组：

eg1：

l = ['a','b','c','d','e']
a = l[1:4 ]
print(l)   //['a', 'b', 'c', 'd', 'e']
print(a)   //['b', 'c', 'd']    

eg2：

l = ['a','b','c','d','e']
a = l[1:4:2]
print(l)  //['a', 'b', 'c', 'd', 'e']

print(a) //['b', 'd']

eg3：

l = ['a','b','c','d','e']

a = l[1:-2:1]

print(l)   //['a', 'b', 'c', 'd', 'e']

print(a)  //['b', 'c']

三、元祖
tuple创建后不能修改，与list区别在于用()替代[]
可以继续使用下标访问
t = ('aa',1,True);
t[0]、t[-1]

t = () //解析为()
t = (1)//单元素这样会被解析成1 ，有歧义，所以单元素要写为 t=(1,)
t = (1,2,3) //解析为(1,2,3)

tuple结合list创建一个可变的tuple
t = ('a','b',['xx','yy']);
l = t[2]
l[0] = 'aa'
l[1]='bb' 
print t //('a','b',['aa','bb'])

【注】：元祖中的数组可以删除，但是不能全部删除，最少留一个 

8*(8)   //64

8*(8,) //(8,8,8,8,8,8,8,8)

元祖虽然不可变，但是可以通过拼接使元祖“可变”

t = (1,2,4,5)
t = t[:2] + (3,) + t[2:]
print(t)   //1,2,3,4,5

四字典

1、创建字典
a = dict([('cc',11),('dd',22)])   或者 a = dict((('cc',11),('dd',22)))  
2、b = {}
      b.fromkeys((1,2,3)) //{1:None,2:None,3:None}
      b.fromkeys((1,2,3),'number') //{1:'number',2:'number',3:'number'}
3、keys、values、items
keys:获取字典所有key
values:获取字典所有values
items:(key,value)的迭代
4、dict.get(key) //不存在key不会报错
5、key in dict //某个key是否存在字典中，在字典中查找键是否存在比在序列中查询值是否存在效率高很多
6、
删除单个字典中元素 dict.pop(key)
删除整个字典dict.clear()
随机删除dict.popitem()
7、copy
a = {1:'aa',2:'bb'}
a = b 
c = a.copy()
b地址与a一样   c地址与a不一样



五、集合set

set1 = ([1,2,3])

set2 = ([2,3,4])

set1 & set2    //{2,3}

set1 | set2    //{1,2,3,4}

set1 = {1,2,3,4,5} //没有value，只有key就是集合
集合中所有元素都是唯一的，无序的



六、系统常用函数
1、abs(-1)//绝对值
2、max(a)、min(a)//最大最小值
3、len(a)//长度
4、divmod(5,2)//(2,1) 商、余数
5、pow(2,3)//2**3 ,2的3次方
     pow(2,3,4)//2的3次方对4取余  0
6、round(1.6)//四舍五入取整
7、callable(test)//test方法可否被调用
8、isinstance(l,list)//l是否是list对象
     isinstance('aa',str)；//true 'aa'是str类型
     type(2) //'bool' 'float' 'int'...变量类型

#type
# type查看类型：type('ss')
# type创建类 （不常用，了解就好）：
def fn(self,name='world'):
    print('Hello,%s' % name)

Hello = type('Hello',(object,),dict(hello=fn,age=11)) #第一个参数字符串“类名”,第二个参数继承的类(一个后面要有“,”),第三个参数属性、方法
h = Hello()
print(h.age) #11
print(h.hello('haha'))#Hello,haha

9、range(1,4,step)//1,2,3  ;一个参数情况下,默认第一个为0
10、type(a)//a的类型
11、int('3')//转成整形
12、str(2)//转成字符串
13、float(2)//转成浮点
14、long(2)//转成长整形
15、complex(2)//转成复合型
16、list(str)//转成列表
17、tuple(l)//转成元祖
18、sum(a)//求和
19、sorted([5,3,1,2])//eg1:1,2,3,5

eg2://高级排序

students = [['zz',12],['cc',5],['343',11]]  

vb = sorted(students,key=lambda st:st[1])

print(vb)

[['cc', 5], ['343', 11], ['zz', 12]]
20、reversed(number) 
21、import sys
       sys.setrecursionlimit(1000000)// 设置递归次数限制
22、import random
       random.randint(1,10) //在1到10中随机生成一个整形数字
       random.choice(['a','b','c','d','e']) //随机选择 
       random.random() //获取小数

七、字符串

1、str.capitalize('aa') //首字母大写

2、str.replace('a','b')//将a换成b 

3、str.split(',')//按照','分隔

4、str.lower()//全小写

5、str.upper()//全大写

6、str.find('a')//查询,不存在返回-1

7、str.[l,r]strip()//去空格,指定字符

8、str.count('a')//a出现多少次

9、','.join(str|list)//,组合
10、str.startswith('asv')//是否以asv开始、str.startswith('asv',3,6)
       str.endswith('vb')//是否已vb结尾  str.endswith('vb',3,5)
11、str.islower()
12、str.istitle()
13、str.isnumeric()
14、str.isalpha()

15、转义字符串中特殊符号，比如“\”

15.1 方法一：str1 = "C:\\a\b"

15.2 方法二：str2 = r"C:\a\b"  ，但是最后不能加“\”,如果非要加可以用字符串连接 str2 = str2 + "\\"

16、打印多行带换行的字符串用 ''' .....''':

str1 = '''张三
里斯
王五
'''

...
 八、序列处理函数
map(lambda x:x+1,[1,2,3])//2,3,4
filter(lambda x:x%2=0,[1,2,3])//[2] 
reduce(lambda x,y:x+y,[1,2,3,4])//10 
reversed([1,4,2,3])//返回生成器
list(reversed([1,4,2,3]))//4,3,2,1
enumerate(number)//[(0,1),(1,4),(2,2),(3,3)]
zip

 

九 、格式化
%d //去尾法取整
%.2f //四舍五入有保留2位小数
%s //字符串

%c //格式化 asc码 ：   '%c' % 97 ，  输出a ； '%c  %c  %c ' % (97,98,99)  ,  输出a b c

1、创建集合
set1 = {1,2,3} 或者 set1 = set([1,2,3])
 2、set1.add(4) //添加
       set1.remove(4) //删除
3、添加不可变的集合
    set2=  frozenset([1,2,3])//不可变的

 十、系统OS模块函数
 import os
//os
os.environ.get('PATH') //获取环境变量
os.getcwd()//获取当前文件夹
os.chdir('/')//切换路径 
os.mkdir('test',0777)
os.makedirs('a/v/c',0777)//创建递归文件夹
os.rmdir('test')//删除
os.removedirs('a/v/c') //删除递归文件夹
os.listdir('/')// 列出文件夹
os.walk('/')//循环递归 列出文件

os.rename('old.txt','new.txt')//删除文件
os.remove('xx.txt')//删除文件
os.seq //widows为\\,linux为/
os.name//操作系统
os.system('ls -l') //运行系统shell命令

//os.path
os.path.basename('/home/www/test.txt') //test.txt
os.path.dirname('/home/www/test.txt' ) //home/www
os.path.split('/home/www/test.txt') //  (/home/www,'test.txt')
os.path.split('/home/www/dir1’)    //(/home/www,'dir1')一定要判断传进来的是否是文件，否则就会把最后这一级当成文件
os.path.splitext('/home/www/test.txt')//(/home/www/test,'txt') ,分开扩展
os.path.getsize('/home/www/test.txt')//文件大小,字节数
os.path.getatime(file)//文件最新访问时间
os.path.getctime(file)//文件创建时间
os.path.getmtime(file)//文件最新修改时间
os.path.join(a,b)//将ab两个路径拼凑一起
os.path.exists(path)//判断目录或者文件是否存在
os.path.isdir(path//是否存在而且是一个文件夹
os.path.isfile(path)//是否存在而且是一个文件
os.path.samefile(file1,file2)//两个文件是否指向一个文件
os.path.isabs(path)//是否存在而且是一个绝对路径
os.path.islink(path)//是否存在而且是一个符号链接
os.path,ismount(path)//是否存在而且是一个挂载点
os.path.abspath('.') //查看当前目录的绝对路径
 
十一、存放、读取（序列化）
import pickle
存放 
pickleFile = open('/home/www/test.pkl','wb')//一定要有b，后缀无所谓,创建打开泡菜缸
pickle.dump(['aa','bb','cc'],pickleFile) //将列表倒入test.pkl泡菜缸里
pickleFile  .close()//盖上缸盖 

读取
pickleFile = open('/home/www/test.pkl','rb')//打开泡菜缸
pickle.load(pickleFile)//读取泡菜,['aa','bb','cc']
pickleFile  .close()//关闭泡菜刚
 
十二、类中长用的函数
1、issubclass (parentClass,childClass) //检查childClass是否是parentClass的子类，自己也是自己的子类,childClass也可以是数组，序列等
2、isinstance(obj,class)//对象是否属于该类
3、hasattr(obj,attribute)//对象是否有指定属性,attribute一定为字符串
4、getattr(obj,attribute,defaultValue) //获取对象属性,attribute一定为字符串，没有返回默认defaultValue,没有设置就报错

5、setattr(obj,attribute,value)//给对象设置属性，,attribute一定为字符串
6、delattr(obj,attribute)//attribute一定为字符串,用此方法之前一定要hasattr，否则删除不存在的属性会报错
7、property(getN,setN,delN,docN)

    class My:

def __init__(self,x=10):

self.x = x

def setX(self,x):

self.x = x

def getX(self):

return self.x

def delX(self):

del self.x

n = property(getX,setX,delX)
    
     调用: 

    my = My()

    my.n=1 //调用了getX
    my.n = 1//调用setX 
   del my.n //调用delX 

十三、常用基础知识点
    1、 is与==区别:  http://www.cnblogs.com/CheeseZH/p/5260560.html
           1.1、is检测内存地址,==检测value值 
           1.2、字符串与数值类型,声明赋值，如果内存中检测有此值，不会信开辟内存空间，会将指针指向改内存地址，不浪费，其他序列、元祖、字段、集合任何情况下都肚子开辟空间

    2、python除法(2.x版本，3.x已与其他语言一样)
      21 / 10 = 2 
      21.0 / 10.0 = 2.1 

    3、除了数值0与null、False其他任何值都为true,字符串'0'也为真
 
    4、字符串与数值不能直接比较,要转型

    5、字符串、数字。。不可变与list拷贝区别
        str、int...
       a = 'aa';
       b = a
       a = 'bb';
       print(a)//'bb'
       print(b);//'aa' ,重新搞得一个地址保存

        list
        ll = [3,2,1]
        pp = ll[::];
        mm = ll;
        ll.sort();
        print(ll)//[1,2,3]
         print(pp)//[3,2,1] //从新搞了一个地址保存
        print(pp)//[1,2,3] //与ll指向一个地址
     
    6、检测对象是否可迭代
        from collections import Iterable;
        isinstance([1,2,3],Iterable);//True
        isinstance(123,Iterable);//False
  7、for循环
      7.1    [for x in [1,2,3,4]]//[1,2,3,4]
      7.2    [x*x for x in [1,2,3,4]] //[1,4,9,16]
      7.3    [x*x for x in [1,2,3,4] if x%2==0] //[4,16]
      7.4    [m + n for m in 'ABC' for n in 'XYZ'] //[AX,AY,AZ,BX,BY,BZ,CX,CY,CZ] 
      7.5   循环字典 d = {'a':1,'b':2}
            7.4.1(默认)  for k in d:
                                    print(k);//默认循环的是key //a 、b
            7.4.2(循环val)    for v in d.values():
                                        print(v);// 1,2
            7.4.3(循环k、v)  for i,v in d.items():
                                        print(i,v)//a,1  b,2
    8、funcName.__name__ //方法名字
          装饰器
                import functools

                def log(func):

                        @functools.wraps(func) //修改内部wraps为外部的function

                        def wrapper(*args, **kw):

                      print('call %s():' % func.__name__)

                      return func(*args, **kw)

                    return wrapper

                //或者针对带参数的 decorator：

                import functools

                def log(text):

                    def decorator(func):

                  @functools.wraps(func) //修改内部wraps为外部的function

                  def wrapper(*args, **kw):

                  print('%s %s():' % (text, func.__name__))

                  return func(*args, **kw)

                  return wrapper

                    return decorator

         9、

               improt sys;

               sys.argv  //运行python hello.py a b  ，得到结果['hello.py','a','a']

         10、判断一个数据类型是不是方法

           def fn():

                 pass

           type(fn)==types.FunctionType

            

十四、封装

十五、继承

class Animal(object):

         def run(self):

               print('xxxxxxxxx')

class Cat(Animal):

       ...........

class Dog(Animal):

         ..............

十六、多态

animal = Animal()

animal = Dog()

animal = Cat()

animal = Tortoise()

//以上四个类都有run方法,但是传进去他们会执行各自的方法，自动调用实际类型的 run()方法

def run_twice(animal):

      animal.run() 

      animal.run()

当我们需要传入 Dog、Cat、Tortoise……时，我们只需要接收 Animal 类型就可以了，因为 Dog、Cat、Tortoise……都是 Animal类型，然后，按照 Animal 类型进行操作即可。由于 Animal 类型有 run()方法，因此，传入的任意类型，只要是 Animal 类或者子类，就会自动调用实际类型的 run()方法，这就是多态的意思：

对于一个变量，我们只需要知道它是 Animal 类型，无需确切地知道它的子类型，就可以放心地调用 run()方法，而具体调用的 run()方法是作用在 Animal、Dog、Cat 还是 Tortoise 对象上，由运行时该对象的确切类型决定，这就是多态真正的威力：调用方只管调用，不管细节，而当我们新增一种 Animal 的子类时，只要确保 run()方法编写正确，不用管原来的代码是如何调用的。

十七、日志

import logging

logging.basicConfig(level=logging.INFO)

logging.info('xxxx')

十八、json数据
import json
d = {'a':'a','b':'b'};
json.dumps(d) //转成json字符串
str = "{'a':'a','b':'b'}";

json.loads(str) //将json转成字典对象

 

十九、多线程
1、 linux、os下
iimport os
print('Process (%s) start...' % os.getpid())
# Only works on Unix/Linux/Mac:
pid = os.fork()
if pid == 0: 
    print('I am child process (%s) and my parent is %s.' % (os.getpid(),os.getppid()))
else: 
    print('I (%s) just created a child process (%s).' % (os.getpid(),pid)) 

2、windows没有fork,有multiprocessing模块中Process类支持，代表一个进程对象

from multiprocessing import Process

import os

def run_proc(name):

print('Run child process %s %s...,我的父进程为 %s' % (name,os.getpid(),os.getppid()))

if __name__ == '__main__':

print('Parent process %s' % os.getpid())

p = Process(target = run_proc,args=('test',))

print('子进程将要开始...')

p.start()

p.join()

print('子进程结束。')

二十、界面编程：easyGUI

二十一、python图片处理，生成缩略图

pip install Pillow

from PIL import Image

im = Image.open('test.png')

print(im.format,im.size,im.mode)  #PNG  (400,300)  RGB

im.thumbnail(200,100)

im.save('thumb.jpg','JPEG')