美文网首页
Python基础

Python基础

作者: 将军红 | 来源:发表于2019-12-19 17:00 被阅读0次

1. py2 vs py3

  1. 字符编码
    py2.7: 默认ascii,字符分unicode+str
    py3: 默认utf-8:, str+byte

  2. 语法
    整除,print,raw_input,
    py2.7: range list != xrange 迭代器
    py3: range = xrange: 都是迭代器

2. 迭代器 -> 生成器

迭代器: [] 预先分配一块内存存储, 可随意读取;
生成器: 特殊的迭代器,只能迭代一次,调用时内存中存

迭代器概念:迭代器是访问集合元素的一种方式,从集合的第一个元素开始访问,直到所有的元素被访问完结束,顺序不能倒着来。
list,tuple 用index 和 迭代器都可以访问。但对于无法随机访问的数据结构(比如set)而言,迭代器是唯一的访问元素的方式。
next方法:返回迭代器的下一个元素, iter方法:返回迭代器对象本身
for语法糖: for循环内部事实上就是先调用iter()把Iterable变成Iterator在进行循环迭代的。

yield 的作用就是把一个函数变成一个 generator,带有 yield 的函数不再是一个普通函数,Python 解释器会将其视为一个 generator。

3. 一般函数,classmethod, staticmethod

class method: 不管这个方式是从实例调用还是从类调用,它都用第一个参数把类传递过来

staticmethod 本质跟全局函数一样

foo方法绑定对象A的实例,class_foo方法绑定对象A,static_foo没有参数绑定。
class_foo, static_foo 都可以通过A, a调用,foo只能通过a调用

vs classmethod: classmethod 可以做需要class参与的动作;staticmehod不行
vs normalmethod: staticmethod本质上就是一个函数,调用方式和调用函数一样,不同的是它不关注对象和对象内部属性。
vs 全局函数: 写到外部会混乱,让类不可控。写到类里面可以很好组织代码,可以继承

list, tuple, set

tuple: t = (1,1,2) 可重复,初始化后不能更改,加减
set: 没有重复

In [12]: s = set([1,1,2])

In [13]: s
Out[13]: {1, 2}

In [14]: s.add(3)

In [15]: s
Out[15]: {1, 2, 3}

5. metaclass, new, init

元类

__metaclass__, __new__, __init__

metaclass,直译为元类,简单的解释就是:

当我们定义了类以后,就可以根据这个类创建出实例,所以:先定义类,然后创建实例。

但是如果我们想创建出类呢?那就必须根据metaclass创建出类,所以:先定义metaclass,然后创建类。

Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class
要创建一个class对象,type()函数依次传入3个参数:

  1. class的名称;
  2. 继承的父类集合,注意Python支持多重继承,如果只有一个父类,别忘了tuple的单元素写法;
  3. class的方法名称与函数绑定,这里我们把函数fn绑定到方法名hello上。

6. list, tuple, dict, set

Python中常见的数据结构可以统称为容器(container)。而序列(如列表和元组)、映射(如字典)以及集合(set)是三类主要的容器

关注:索引(indexing)、分片(sliceing)、加(adding)、乘(multiplying)以及检查某个元素是否属于序列的成员。除此之外,还有计算序列长度、最大最小元素等内置函数

6.1 list

l1 = ['hello', 1]
l2 = list('hello') # ['h', 'e', 'l', 'l', 'o']
nums=range(10)

nums[0] # 索引 , l1[-1]
nums[1:5]   # [1, 2, 3, 4]
nums[1:]    # [1, 2, 3, 4, 5, 6, 7, 8, 9]
nums[-3:-1] # [7, 8]
nums[-3:]   # [7, 8, 9]
nums[:] #复制整个序列

str1 = 'Hello'
print len(str1) 
print max(str1) # o
print min(str1) # H

In [20]: a = [1,9,3,3,2,2]

In [21]: a.sort()

In [22]: a
Out[22]: [1, 2, 2, 3, 3, 9]
or 
In [31]: a = [1,9,3,3,2,2]

In [32]: sorted(a)
Out[32]: [1, 2, 2, 3, 3, 9]

In [33]: a
Out[33]: [1, 9, 3, 3, 2, 2]


In [23]: t = tuple([1,5,2,3,2])
In [28]: t2 = sorted(t)

In [29]: t2
Out[29]: [1, 2, 2, 3, 5]

In [30]: t
Out[30]: (1, 5, 2, 3, 2)



6.2 tuple 【除了创建和增加,其他属性同list】

t1=1,2,3    # t1=tuple([1,2,3]), t2=tuple("jeff")
t2="jeffreyzhao","cnblogs"
t3=(1,2,3,4)    # =t3=tuple((1,2,3,4))
t4=()
t5=(1,)

6.3 dict (键可以为任何不可变类型, 列表和集合不能作为字典的键。)

d.update({'a': ord('a')})
d.clear()
d.fromkeys(['a', 'b', 'c']) # Out[16]: {'a': None, 'b': None, 'c': None}
In [19]: d.fromkeys(['a','b','c'], 2) # Out[19]: {'a': 2, 'b': 2, 'c': 2}
d.pop(key[,default]) # 删除字典给定键 key 所对应的值,返回值为被删除的值。key值必须给出。 否则,返回default值。

如果要降序排序,可以指定reverse=True

sorted_x = sorted(x.iteritems(), key=lambda x : x[1])

6.4 set

集合元素的顺序是随意的, 理解集合为没有value的字典

strs=set(['jeff','wong','cnblogs']) # print  {'cnblogs', 'jeff', 'wong'}
# 按照value排序
# 默认是升序
In [29]: d = {'a':1, 'b':-7}

In [30]: sorted(d.items(), key=lambda x: x[1])
Out[30]: [('b', -7), ('a', 1)]
# 降序sorted加reverse=True参数

# 按key排序
n [36]: sorted(d.items(), key=lambda x:x[0])
Out[36]: [('a', 1), ('b', -7)]

In [37]: sorted(d.items(), key=lambda x:x[0], reverse=True)
Out[37]: [('b', -7), ('a', 1)]

交集union or &

set3=set1.union(set2)
set3=set1&set2

并集

set3=set1|set2

x - y # 差集

set(['p', 's'])

add和remove
字典的key(集合)是不可变的, 集合本身只能包含不可变值,所以也就不能包含其他集合

set1.add(set2) # TypeError: unhashable type: 'set'

set1.add(frozenset(set2)) # set([1, frozenset([2])])

strs=set(['jeff','wong','cnblogs'])
nums=set(range(10))

7. Python自省

type(),dir(),getattr(),hasattr(),isinstance().

自省(让对象告诉我们他是什么),用于实现在运行时获取未知对象的信息。
访问对象属性/方法:
hasattr(obj, attr) 这个方法用于检查obj是否有一个名为attr的值的属性,返回一个布尔值。
getattr(obj, attr) 调用这个方法将返回obj中名为attr值的属性的值,例如如果attr为’bar’,则返回obj.bar。
setattr(obj, attr, val) 调用这个方法将返回obj中名为attr值的属性的值,例如如果attr为’bar’,则返回obj.bar。

In [43]: class A:
...: _a = None
...: _b = None
...: def f_a():
...: pass
...:

In [44]: a = A()

In [45]: hasattr(a, '_a')
Out[45]: True

In [46]: hasattr(a, 'f_a')
Out[46]: True

8. Python中单下划线和双下划线

  1. 单下划线函数和变量,用来指定私有,内部用。
  2. 双下划线__foo,解析器用_classname__foo来代替这个名字,以区别和其他类相同的命名.
    dir(Test) 时会看到 _Test__x
  3. __foo__: Python内部专有

9. format & %

9.1 %

"hi there %s" % name
当 name=(1,2,3)时会抛异常,所以不会出错的方式是:
"hi there %s" % (name,) # 提供一个单元素的数组而不是一个参数

9.2 format

1.通过位置:
print ("{0},{1}".format('lujf',123))
2.通过关键字参数:
print ("{name},{age}".format(name='lujf',age=23))
3.通过下标:
p = ['lujf',23]
print ('{0[0]},{0[1]}'.format(p))
4.通过对象属性

def __str__(self):
      return 'This guy is {self.name},is {self.age} old'.format(self=self)

10 缺省参数对函数的绑定

缺省参数在python中是与函数绑定在一起的。

也就是说,一个函数中定义了一个缺省参数,那么这个参数会随着被调用而改变。(一个坑)

在一次调用中改变了缺省参数的值,可能会影响到这个函数的另外一次调用。

def f(a,L=[]):  
    L.append(a)  
    print L  
f(1)  #[1]
f(2)  #[1,2]

11. __new__ && __init__

new是在实例创建之前被调用的,因为它的任务就是创建实例然后返回该实例,是个静态方法
init是当实例对象创建完成后被调用的,然后设置对象属性的一些初始值。

class Book(object):
    def __new__(cls, title):
        print'__new__'
        return super(Book, cls).__new__(cls)

    def __init__(self, title):
        print'__init__'
        super(Book, self).__init__(self)
        self.title = title


b = Book('The Django Book')
print(b.title)

12. copy(),deepcopy()

import copy
a = [1, 2, 3, 4, ['a', 'b']]  #原始对象
 
b = a  #赋值,传对象的引用
c = copy.copy(a)  #对象拷贝,浅拷贝 等价于 c = a[:]
d = copy.deepcopy(a)  #对象拷贝,深拷贝
 
a.append(5)  #修改对象a
a[4].append('c')  #修改对象a中的['a', 'b']数组对象
 
print 'a = ', a
print 'b = ', b
print 'c = ', c
print 'd = ', d


a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]   # b赋值,跟赋值的list走(包括里面的二层list)
c =  [1, 2, 3, 4, ['a', 'b', 'c']]  # 浅拷贝,拷贝的list外层,不会改变。里面二层list会变。
d =  [1, 2, 3, 4, ['a', 'b']]   # 深拷贝,所有的值完全拷贝一份。

a = [1,2]
b=a
a = [3,4]

# a = [3,4]
# b = [1,2] b赋值,跟赋值的list走(包括里面的二层list)

13. 读取文件

read 读取整个文件。
readline 读取下一行,使用生成器方法。
readlines 读取整个文件到一个迭代器以供我们遍历。

14. 新式类和旧式类

  1. 新式类是在创建的时候继承内置object对象(或者是从内置类型,如list,dict等),而经典类是直接声明的
  2. 新式类,有__new__,__init__等magic method
  3. 新式类有static_method, class_method, 等
  4. 多重继承的问题: 新式类是广度优先,旧式类是深度优先

相关文章

网友评论

      本文标题:Python基础

      本文链接:https://www.haomeiwen.com/subject/imfvnctx.html