python学习笔记-基础

# output name
a = 100
if a > 10:
    print("a>10")
else:
    print("a<=10")

>>> print('\转义: ', '\\\t\\')
\转义:  \    \
>>> print('不转义:', r'\\\t\\')
不转义: \\\t\\
>>> print('多行： ', '''line1
... line2
... line3''')
多行：  line1
line2
line3 

>>> True and True
True
>>> True or Flase
True
>>> not 5 > 1
False

>>> 10 / 3
3.3333333333333335
>>> 10 // 3
3
>>> 10 % 3
1 

>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
>>> 'abc'.encode('ascii')
b'abc'
>>> '中文'.encode('ascii')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'
>>> b'abc'.decode('ascii')
'abc'

>>> len('中文')
2
>>> len('中文'.encode('utf-8'))
6

>>> "Hi, %s, you have %d" % ('peter', 100)
'Hi, peter, you have 100'

>>> "Hi, {0}, you have {1:.2f}".format('peter', 3.1415926)
'Hi, peter, you have 3.14' 

>>> books = ['a', 'b', 'c']
>>> books
['a', 'b', 'c']
>>> len(books)  # 计算list元素的个数
3
>>> books[0]    # 通过索引访问list中的元素，索引下标从0开始
'a'
>>> books[4]    # 超出list的范围会报IndexError错误，最后一个下标是 len-1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> books[-1]   # 下标-1代表最后一个元素，-2是倒数第二个元素，以此类推
'c'
>>> books[-2]
'b'
>>> books.append(True)  # 往list队尾添加元素
>>> books.insert(1, ['abc', 'def'])  # 往list指定下标位置(1)添加元素
>>> books       # list内的元素可以是不同的类型
['a', ['abc', 'def'], 'b', 'c', True]
>>> books.pop() # 从队尾删除元素
True
>>> books.pop(1) # 从list指定下标位置(index=1)删除元素
['abc', 'def']
>>> books;
['a', 'b', 'c']
>>> books[1] = 'abc' # 可以类似数组，直接替换指定下标位置的元素
>>> list = list(range(5))   # 通过range()函数生成0-4的整数序列，再通过list()函数转换为list
>>> list
[0, 1, 2, 3, 4] 

>>> books = (1,2,['a','b'])  # 通过(... , ...)定义tuple
>>> books
(1, 2, ['a', 'b'])
>>> books[2][1]
'b' 

>>> dict = {'a':100, 'b':200, 'c':300}
>>> dict['c']           # 根据key获取value
300
>>> dict['Adam'] = 400  # 通过key放入value数据
>>> 'Adam' in dict      # 判断key是否在字典中
True
>>> 'adam' in dict
False
>>> dict.get('Adam')    # key如果不存在，则会返回None
400
>>> dict.pop('a')       # 删除一个key-value对
100

>>> set = set([1,2,3])  # 新建set，以list作为输入集合
>>> set.add(1)          # 往set中添加元素，但set中元素不能重复
>>> set.remove(1)       # 从set中移除元素
>>> s1 = set([1,2,3])
>>> s1
{1, 2, 3}
>>> s2 = set([2,3])
>>> s1 & s2             # 求s1和s2两个set的交集
{2, 3}
>>> s1 | s2             # 求s1和s2两个set的并集
{1, 2, 3} 

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

sum = 0
for x in range(101):
    sum += x
print(sum)

sum = 0
x = 1
while x <= 100:
    sum += x
    x += 1
print(sum)

>>> abs(-1)
1
>>> abs(1,2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: abs() takes exactly one argument (2 given)
>>> abs('abc')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: bad operand type for abs(): 'str'

>>> a = abs     # 将变量a指向函数abs()
>>> a(-1)       # 通过a调用abs()函数
1 

def my_abs(x):
    if not isinstance(x, (int, float)):     # 检查 x 的数据类型
        raise TypeError("type error")       # 抛出TypeError异常
    if x >= 0:
        x;
    else:
        return -x;

print(my_abs(-1))  

if x >= 0:
    pass;

def test(x):
    return 1,2

x, y = test('a')
print(test('a'))
输出：
(1, 2)

def enroll(name, gender, age=6, city='Beijing'):
    # 第3、4个参数设置默认值
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)
    return

print(enroll('a', 'F'))     # 等同于调用enroll('a','F',6,'Beijing')
print(enroll('a', 'F', city='BJ'))  # 当参数不按定义的顺序传递时，需要把参数名写上，此时age还使用默认值

def cacl(*number):      # number接收的是一个tuple
    for x in number:
        print(x)

cacl()
cacl(1,2,3)         # 函数可以传任意值
nums = [1,2,3]
cacl(*nums)         # nums前加一个*，将list或tuple的值作为可变参数传递

def person(name, age, **kw):
    print('name', name, 'age', age, 'others', kw)

# 可传入任意个关键字参数
person('peter', 10, gender='M', job='Engineer')

# 可先组装dict，然后通过**dict将所有key-value用关键字参数传入函数的**kw，kw获得dict的一份拷贝，对kw的改动不会影响外面的dict
dict = {'gender':'M', 'job':'Engineer'}
person('peter', 10, **dict)

def person(name, age, **kw):
    if 'city' in kw:        # 检查是否有city和job参数
        print(kw['city'])
    if 'job' in kw:
        print(kw['job'])
    print(name, age, kw)

def person(name, age, *, city, job):    # 只接收city和job作为关键字参数
    print(name, age, city, job)

# 命名关键字参数必须传入参数名，如果没有传入参数名，则调用会报错
person('name', 18, city='city', job='job')  

def func(n):
    if n == 1:
        return 1
    return n * func(n-1) 

>>> L = ['a','b','c','d','e']
>>> L[0:3]              # 取前3个元素，从索引0到索引3（但不包括索引3）的元素
['a', 'b', 'c']
>>> L[:3]               # 如果第一个索引是0，可以省略
['a', 'b', 'c']
>>> L[-2:-1]            # 倒数切片，倒数第2个元素，倒数第一个元素索引是-1
['d']
>>> L[-2:]              # 倒数前2个元素
['d', 'e']
>>> L[0:5:2]            # 取前5个元素，每2个取一次
['a', 'c', 'e']
>>> L[::2]              # 取所有元素，每2个取一次
['a', 'c', 'e']

>>> (1,2,3,4,5)[:3]
(1, 2, 3)

>>> 'abcde'[:5:2]
'ace' 

# 迭代list
>>> l = list(range(10))
>>> for item in l:
...     print(item)

# 迭代dict，由于dict的存储不是像list那样顺序存储，所有迭代结果可能不是按顺序的
>>> d = {'a':1, 'b':2}
>>> for key in d:               # 默认是迭代的key
...     print(key)
...
b
a
>>> for value in d.values():    # 迭代value
...     print(value)
...
2
1
>>> for k,v in d.items():       # 迭代key和value
...     print(k, v)
...
b 2
a 1

# 迭代字符串
>>> for ch in 'abc':
...     print(ch)
...
a
b
c

>>> from collections import Iterable
>>> isinstance('abc', Iterable)     # str类型可迭代
True
>>> isinstance(123, Iterable)       # 整数不可迭代
False
>>> dict={'a':1}
>>> isinstance(dict, Iterable)      # dict类型可迭代
True

>>> l = ['a','b','c','d']
>>> for i,value in enumerate(l):
...     print(i, value)
...
0 a
1 b
2 c
3 d

# 生成 2-10 的list
>>> L=list(range(2,11))
>>> L
[2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> L=[x * x for x in range(3,11) if x % 2 ==0]
>>> L
[16, 36, 64, 100]

>>> L=[]
>>> for x in range(3,11):
...     if x % 2 == 0:
...         L.append(x * x)
...
>>> L
[16, 36, 64, 100]

>>> dict={'a':'1', 'b':'2'}
>>> [k+'='+v for k,v in dict.items()]
['b=2', 'a=1'] 

>>> L = [x * x for x in range(1,10)]    # 创建list
>>> L                                   # 打印list的每一个元素
[1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(1,10))    # 创建generator
>>> g
<generator object <genexpr> at 0x1024e0bf8>
>>> next(g)     # 用next()函数获取generator下一个返回值
1
>>> next(g)
4

>>> g = (x * x for x in range(1,5))
>>> for n in g:
...     print(n)
...
1
4
9
16

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

fib(6)      # 输出菲波那切数列前6个数

>>> def fib(max):
...     n, a, b = 0, 0, 1
...     while n < max:
...         yield b
...         a, b = b, a + b
...         n = n + 1
...     return 'done'
...
>>> g = fib(6)  # 生成generator对象
>>> g
<generator object fib at 0x1024e0bf8>
>>> next(g)     # 调用next()函数不断获取后一个返回值
1
>>> next(g)
1
>>> next(g)
2
>>> next(g)
3
>>> next(g)
5
>>> next(g)
8
>>> next(g)     # 此时 n = max, 没有yield可以执行了，所有调用就报错了
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration: done

>>> for n in fib(6):    # 也可以使用for循环进行generator的迭代
...     print(n) 

>>> isinstance([],Iterable)
True
>>> isinstance((x for x in range(10)),Iterable)
True
>>> isinstance(123,Iterable)
False

>>> from collections import Iterator
>>> isinstance([],Iterator)
False
>>> isinstance((x for x in range(10)), Iterator)
True

>>> abs(-10)        # 调用求绝对值的函数
10
>>> abs             # abs是函数本身
<built-in function abs>
>>> f=abs           # 将函数本身赋值给变量
>>> f
<built-in function abs>
>>> f(-10)          # 通过变量来调用函数。直接调用abs()和调用变量f()相同
10

def add(x, y, f):
    print(f(x) + f(y))

add(-5, 6, abs)     # f=abs 作为参数传入, 最后计算abs(-5) + abs(6)

输出：11 

# 第一个参数str是str()函数，将list中的每个数字转化为str
>>> result = map(str, [1,2,3,4,5])  
>>> isinstance(result, Iterator)
True
>>> list(result)        # 结果是Iterator惰性序列，通过list()函数将其转化为list
['1', '2', '3', '4', '5']

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

>>> from functools import reduce
>>> def fn(x, y):
...     return x * 10 + y
...
>>> reduce(fn, [1,3,5,7,9])
13579

>>> DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
# str也是一个Iterable
>>> reduce(lambda x, y:x*10 + y, map(lambda x:DIGITS[x], '13579')) 
13579

>>> help(filter)

Help on class filter in module builtins:

class filter(object)
 |  filter(function or None, iterable) --> filter object
 |
 |  Return an iterator yielding those items of iterable for which function(item)
 |  is true. If function is None, return the items that are true.

>>> def is_odd(n):
...     return n % 2 == 1
...
# filter返回Iterator序列,需要用list()来获取所有结果
>>> list(filter(is_odd, [1,2,3,4,5]))   
[1, 3, 5]

# 对list进行排序
>>> sorted([1, -5, 3])      
[-5, 1, 3]
# 接收key函数实现自定义排序，按绝对值大小排序
>>> sorted([1, -5, 3], key=abs)     
[1, 3, -5]
# 反向排序
>>> sorted([1, -5, 3], key=abs, reverse=True)
[-5, 3, 1]

>>> def lazy_sum(*args):
...     def sum():
...         s = 0
...         for n in args:
...             s = s + n
...         return s
...     return sum      # 返回求和函数
...
>>> f=lazy_sum(1,2,3,4,5)   # 调用lazy_sum时，返回求和函数而不是求和结果
>>> f
<function lazy_sum.<locals>.sum at 0x101c09ae8>
>>> f()                 # 调用f()时，才会计算求和结果
15

# map第一个参数为传入的函数
>>> list(map(lambda x : x * x, [1,2,3]))
[1, 4, 9] 

# 定义能打印日志的装饰器，接收一个函数作为参数，并返回一个函数
import functools

def log(func):
    # 将原始函数now的__name__等属性复制到wapper中，否则部分依赖函数签名的代码执行时会出错
    @functools.wraps(func)      
    def wapper(*args, **kw):
        print("call %s" % func.__name__)
        return func(*args, **kw)
    return wapper

# 使用@语法，将装饰器置于函数的定义处
@log
def now():
    print("2018-01-01")

now()   # 调用now函数，不仅运行now本身，也会在now之前打印一行日志

---
call now
2018-01-01

>>> int('123')
123
>>> int('123', base=8)  # 按8进制进行转换
83

>>> import functools
>>> int2=functools.partial(int, base=2)
>>> int2('100101')
37
>>> int2('100101',base=10)
100101

mycompany
├─ __init__.py
├─ abc.py
└─ xyz.py

# class关键字定义类，后面object表示Student是从object继承的，
class Student(object):
    
    # 通过定义特殊的__init__方法，在创建类时，将必须绑定的属性强制填写进去
    # __init__第一个参数是self，表示实例本身，在内部将name和score属性绑定到self上
    def __init__(self, name, score):
        self.name = name
        self.score = score

    def print(self):
        print("%s %s" % (self.name, self.score))

# 创建Student实例，必须传入与__init__方法匹配的参数
std = Student("name", 90)   
# Student实例将name和score数据封装起来，通过调用实例的方法，操作对象的内部数据
std.print()     

class Student(object):
    def __init__(self, name, score):
        self.__name = name
        self.__score = score
    def print_score(self):
        print("%s, %s" % (self.__name, self.__score))

class Animal(object):
    def run(self):
        print('animal run')

# Cat类继承自Animal类
class Cat(Animal):
    # 将父类中的run方法覆写掉
    def run(self):
        print('cat run')

# 该函数接受Animal类型的变量
>>> def run_twice(animal):
...     animal.run()
...     animal.run()
...
>>> run_twice(Animal())     # 当传入Animal对象时
animal run
animal run
>>> run_twice(Cat())        # 当传入Cat对象时
cat run
cat run

# 判断基本类型
>>> type(123)
<class 'int'>
>>> type('123')
<class 'str'>

# 如果一个变量指向一个类或函数
>>> type(Cat())
<class '__main__.Cat'>
>>> type(abs)
<class 'builtin_function_or_method'>

>>> type(123)==type(456)
True
>>> type('abc')==str
True
>>> type('abc')==type(123)
False

>>> a = Animal()
>>> c = Cat()
>>> isinstance(a, Animal)
True
>>> isinstance(c, Animal)
True
>>> isinstance(a, Cat)
False

# 判断基本类型
>>> isinstance(123, int)
True
>>> isinstance('123', int)
False

>>> a = Animal()
>>> dir(a)
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'run']
>>> hasattr(a, 'x')         # 是否有'x'属性
False
>>> setattr(a, 'x', 10)     # 设置属性'x'
>>> getattr(a, 'x')         # 获取属性'x'
10

>>> fn = getattr(a, 'run')  # 获取a对象的run方法，赋值到变量fn
>>> fn()                    # fn()与a.run()是一样的
animal run 

>>> a = Animal()
>>> a.score = 123

>>> class Animal(object):
...     name = "name"
...
>>> a = Animal()
>>> a.name      # 实例a没有name属性，会查找class的name属性
'name'
>>> Animal.name # 打印类的name属性
'name'
>>> a.name='name_object'    # 给实例a绑定name属性
>>> a.name                  # 实例属性优先级比类属性高，所有屏蔽了类的name属性
'name_object'

>>> class Student(object):
...     __slots__=('name','age')    # 通过tuple设置允许绑定的属性明恒
...
>>> a = Student()
>>> a.name="name"       # 绑定属性name
>>> a.other=123         # 绑定属性other，不在__slots__定义中，出现错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'other'

>>> class Student(object):
...     @property   
...     def score(self):
...         return self._score
...
...     @score.setter
...     def score(self, value):
...         if not isinstance(value,int):
...             raise ValueError('score must be integer')
...         if value > 100 or value < 0:
...             raise ValueError('score must between 0-100')
...         self._score=value

>>> s = Student()
>>> s.score=-1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 10, in score
ValueError: score must between 0-100
>>> s.score=10      # 实际转化为s.set_score(10)
>>> s.score         # 实际转化为s.get_score()
10

class Dog(Animal, RunnableMixIn):
    pass

>>> class Student(object):
...     def __init__(self,name):
...         self.name = name
...     def __str__(self):
...         return 'student object (name:%s)' % self.name
...
>>> print(Student('apple'))
student object (name:apple)

>>> class Fib(object):
...     def __init__(self):
...         self.a, self.b = 0, 1   # 初始化计数器 a,b

...     def __iter__(self):
...         return self             # 返回迭代对象自己

...     def __next__(self):
...         self.a, self.b = self.b, self.a + self.b    # 计算下一个值
...         if self.a > 100:        # 退出循环的条件
...             raise StopIteration()
...         return self.a           # 返回下一个值
...
>>> for n in Fib():
...     print(n)

>>> class Student(object):
...     def __getattr__(self, attr):
...         if attr=='age':
...             return 18
...         if attr=='name':
...             return lambda:'name'
...
>>> stu.name()
'name'
>>> stu.age
18 

>>> from enum import Enum
>>> Sex=Enum('Sex', ('Male', 'Female'))     # 获得Sex类型的枚举类

>>> for name, member in Sex.__members__.items():    # Sex所有成员
...     print(name, '->', member, '->', member.value)
...
# value属性从1开始自动赋值给枚举成员
Male -> Sex.Male -> 1
Female -> Sex.Female -> 2

>>> from enum import Enum, unique
>>>
>>> @unique     # unique装饰器检查没有重复值
... class Sex(Enum):
...     Male=10     # 自定义设置value
...     Female=20

# 使用枚举类型
>>> print(Sex.Male) 
Sex.Male
>>> print(Sex.Male.value)
10
>>> print(Sex(10))      # 根据value值获取枚举常量
Sex.Male 

try:
    运行代码...
except ValueError as e:
    # try中代码如果出错，会跳转至except语句块处理对应的异常
finally:
    # 执行完except后，最终会到finally语句块（不出现错误，也会执行finally）

def foo(s):
    n = int(s)
    if n==0:
        raise ValueError('invalid value: %s' % s)
    return 10 / n 

>>> try:
        # 以读文件方式打开文件对象，如果文件不存在，会抛出IOError错误
...     f = open('/Users/butterfly/test.txt', 'r')  
...     print(f.read())     # 一次读取文件的全部内容到内存中
... finally:
...     if f:
        # 最终，要关闭文件，文件使用后必须关闭，因为文件对象会占用OS的资源，并且OS同一时间打开的文件数量是有限制的
...        f.close()        

>>> with open('/Users/zhangqi/test.txt', 'r') as f:
...     print(f.read())

>>> f = open('/Users/michael/gbk.txt', 'r', encoding='gbk', errors='ignore')

>>> with open('/Users/zhangqi/test.txt', 'w') as f:
...     f.write('hello world')

>>> from io import StringIO
>>> f = StringIO()
>>> f.write('hello\nworld\n')   # 像文件一样写入
12
>>> print(f.getvalue())         # 获取写入后的str
hello
world

>>> from io import BytesIO
>>> f = BytesIO()
>>> f.write('中文'.encode('utf-8'))     # 写入经过utf-8编码的bytes到BytesIO
6
>>> print(f.getvalue())
b'\xe4\xb8\xad\xe6\x96\x87' 

# 环境变量
>>> import os
>>> os.environ      # 查看操作系统中定义的环境变量
>>> os.environ.get('PATH')      # 获取某个环境变量中的值

# 目录操作
>>> os.path.abspath('.')        # 查看当前目录的绝对路径
>>> os.mkdir('/Users/michael/testdir')   # 创建一个新目录
>>> os.rmdir('/Users/michael/testdir')   # 删除一个目录 
# 将路径拆分为两部分，后一部分是最后级别的目录或文件名
>>> os.path.split('/Users/michael/testdir/file.txt')    
('/Users/michael/testdir', 'file.txt')
# 通过splitext可直接获得文件的扩展名
>>> os.path.splitext('/path/to/file.txt')
('/path/to/file', '.txt')

# 文件操作
>>> os.rename('test.txt', 'test.py')    # 对文件重命名
>>> os.remove('test.py')                # 删除文件

# 可方便的列举当前目录下的.py文件
>>> [x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py']