Python基础笔记

淩亂°似流年 2022-05-31 13:13 300阅读 0赞

(1) r’ ’ 表示’ ‘中的内容不转义，转义符号用 \\  
(2) 理解变量在内存中的表示：  
a = ‘ABC’  
Python解释器做了两步工作：1）在内存中创建一个字符串’ABC’ 2）在内存中创建一个名字为a的变量，并把它指向’ABC’  
b = a  
意思是赋值，把变量a赋值给变量b，即变量b指向变量a指向的数  
(3) Python允许用”’ ””来表示多行数据

>>> print ('''1111 ... 222 ... 333 ... 444''')
    1111
    222
    333
    444
    >>>

(4) //与/的区别

>>> 10/3
    3
    >>> 10.0/3
    3.3333333333333335
    >>> 10//3
    3
    >>> 10.0//3
    3.0

// 只取结果的整数部分，所以即使除不尽也是整数  
(5) 格式化练习题：  
小明的成绩从去年的72分提升到了今年的85分，请计算小明成绩提升的百分点，并用字符串格式化显示出’xx.x%’，只保留小数点后1位：

s1 = 72
     s2 = 85
     r = 100*(float(s2-s1)/s1)
     print('%.1f %%' % r)

#使用format()来格式化，传入的参数依次替换{0}{1}...
    print ('{0}成绩提升了{1:.1f}%'.format('小明',r))
    
    小明成绩提升了18.1%
    >>>

(6) 列表list  
下标索引比元素少1，添加元素append()，插入元素insert()，删除元素pop()

classmates = ['Maria','Jane','Michcel']
     classmates.insert(2,'Peter')
     classmates.pop(1)
    'Jane'

(7) 元组tuple  
1) 元组与列表很类似，唯一的区别在于一旦初始化就不能被修改。因此代码比较安全！但可以通过list进行修改！！

t = ('a','11',['A','B'])
     t[2][0]='x'
     t[2][1]='y'
     >>> t
    ('a', '11', ['x', 'y'])

2) 为了与数学运算小括号区别，如果是1个元素时就加个逗号

>>> t = (1)
    >>> t
    1
    >>> t = (1,)
    >>> t
    (1,)
    >>>

(8) 字典dict  
在其他语言中也称为map，使用键-值(key-value)对存储，具有极快的查找速度。  
key如果不存在就会报错，因此需要判断key是否存在。有两种方式：

d = {
       'Maria':80,'Michcel':60,'Peter':90}
    >>> d
    {
       'Michcel': 60, 'Peter': 90, 'Maria': 80}
    >>> d.get('Thomas',-1)
    -1
    >>> 'Thomas' in d
    False
    >>>

用pop(key)删除元素：

>>> d.pop('Peter')
    90
    >>> d
    {
       'Michcel': 60, 'Maria': 80}
    >>>

与list比较
    1）查找和插入速度极快
    2）需要占用大量的内存
    是用空间换取时间的方法
    
    dict的key必须是不可变对象，因为dict根据key来计算对应的value的存储位置。使用的算法是hash算法。

（9） Set  
set与dict类似，也是一组key的集合，唯一的区别在于不存储value。因此key不能重复。  
要创建一个set，需要**提供一个list作为输入集合**：

>>> s = set([1,2,3])
    >>> s
    set([1, 2, 3])
    >>> ss = set(1,2)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: set expected at most 1 arguments, got 2
    >>> ss = set(1)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'int' object is not iterable

重复元素会被自动过滤，添加元素add()，删除元素remove():

s = set([1,1,2,2,2,3])
    >>> s
    set([1, 2, 3])
    >>> s.add(4)
    >>> s
    set([1, 2, 3, 4])
    >>> s.remove(2)
    >>> s
    set([1, 3, 4])

set可看成数学意义上的无序和无重复元素的集合，可进行交、并操作。

s1 = set([2,3,4])
    >>> s&s1
    set([3, 4])
    >>> s |s1
    set([1, 2, 3, 4])

分别将（1，2，3）和（1，2，[3]）放入dict和set中：

dq = {(1,2,3):1}
    >>> dq {(1, 2, 3): 1}
    >>> dq = {(1,2,[3]):1}
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: unhashable type: 'list'
    
    dq = {(1,2,3)}
    >>> dq
    set([(1, 2, 3)])
    
    s2 = {
       1,2,3}
    >>> s2
    set([1, 2, 3])
    >>>

s = set((1,2,3)) >>> s set([1, 2, 3]) >>> s = set((1,2,[3])) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unhashable type: 'list'

说明元组tuple也是可迭代对象！！

(10) 可变元素与不可变元素

a = 'abc'
    >>> b = a.replace('a','A')
    >>> b
    'Abc'
    >>> a
    'abc'
    >>>

为什么a没有变？？  
始终牢记：a是一个变量，’abc’才是一个对象！  
当调用replace时，其作用是在字符串对象’abc‘上。它创建了一个新的字符串’Abc’并返回，b指向其返回值。

(11) 函数  
1）def power(x,n=2) 默认参数要放在必选参数之后？？？  
2）函数的默认参数必须是不变对象（不能是list）

>>> def add_end(L=[]):
    ...     L.append('END')
    ...     return L
    ...
    >>> add_end()
    ['END']
    >>> add_end()
    ['END', 'END']
    >>> add_end()
    ['END', 'END', 'END']
    >>>

原因：Python函数在定义时，默认参数L的值就被计算出来了，即\[\]，因为默认参数L是一个变量指向对象\[\]，每次调用该函数，如果\[\]中的内容已改变，则下次调用时就会跟着改变。  
更改如下：

>>> def add_end(L=None):
    ...     if L is None:
    ...             L = []
    ...     L.append('END')
    ...     return L
    ...
    >>> add_end()
    ['END']
    >>> add_end()
    ['END']
    >>>

3）定义可变参数，直接在参数前加个*即可！在函数内部，参数numbers接收到的是一个tuple

>>> def calc(*numbers):
    ...     sum = 0
    ...     for n in numbers:
    ...             sum = sum + n*n
    ...     return sum
    ...
    >>> calc(1,2)
    5
    
    # 如果已经有一个list或tuple，要调用一个可变参数该怎么办？？
    >>> num = [1,2,3]
    >>> calc(*num)
    14
    >>> calc(num)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<stdin>", line 4, in calc
    TypeError: can't multiply sequence by non-int of type 'list' >>>

4）关键字参数
        可变参数在函数内部被组装成tuple;关键字参数则组装成dict

>>> def person(name,age,**kw):
    ...     print('name:',name,age,'other:',kw)
    ...
    >>> person('Jane',20)
    ('name:', 'Jane', 20, 'other:', {})
    >>> person('Jane',20,city='Beijing')
    ('name:', 'Jane', 20, 'other:', {
       'city': 'Beijing'})
    >>>

关键字参数用来拓展函数的功能。例如对于有些是必选项有些事可选项的情况。

# dict作为参数
    >>> extra={
       'city':'Beijing','job':'Engineer'}
    >>> person('Jane',30,**extra)
    ('name:', 'Jane', 30, 'other:', {
       'city': 'Beijing', 'job': 'Engineer'})
    >>>
    # **extra表示把这个dict的所有key-value用关键字参数传入到函数的**kw参数，kw将获得一个dict

5)命名关键字参数（Python3）略
    6）参数组合：*args可变参数，接收的是一个tuple;**kw是关键字参数，接收的是一个dict.

>>> def func(a,b,c=0,*numbers,**kw):
    ...     print'a=',a,'b=',b,'c=',c,'numbers=',numbers,'kw=',kw
    ...
    >>> func(1,2)
    a= 1 b= 2 c= 0 numbers= () kw= {}
    >>> func(1,2,3)
    a= 1 b= 2 c= 3 numbers= () kw= {}
    >>> func(1,2,3,'a','b')
    a= 1 b= 2 c= 3 numbers= ('a', 'b') kw= {}
    >>> func(1,2,3,'a','b',city='Beijing')
    a= 1 b= 2 c= 3 numbers= ('a', 'b') kw= {
       'city': 'Beijing'}
    >>>

kw={
       'job':'Engineer'}
     numbers = [5,6,7,8]
    >>> func(*numbers,**kw)
    a= 5 b= 6 c= 7 numbers= (8,) kw= {
       'job': 'Engineer'}

7)递归函数
    尾递归：在函数返回时调用函数本身，但return语句不能包含表达式。

def fact(n):
        return fact_iter(n, 1)
    
    def fact_iter(num, product):
        if num == 1:
            return product
        return fact_iter(num - 1, num * product)

(12) 切片

>>> L = ['Michael','Maria','Jane','Peter','Bob']
    >>> L[0:3]
    ['Michael', 'Maria', 'Jane']
    >>> L[::2]
    ['Michael', 'Jane', 'Bob']

（13）迭代  
Python中的可迭代对象：list、tuple、dict、字符串  
判断是否是可迭代对象：

>>> from collections import Iterable
    >>> isinstance('abc',Iterable)
    True

Python内置的enumerate()函数可以把一个list变成（索引，元素）对，这样就可以在for循环中同时迭代索引和元素本身。

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

（14）列表生成式

>>> [x*x for x in range(1,11)]
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    >>> [x*x for x in range(1,11) if x %2 == 0]
    [4, 16, 36, 64, 100]
    >>> [m + n for m in 'ABC' for n in 'abc']
    ['Aa', 'Ab', 'Ac', 'Ba', 'Bb', 'Bc', 'Ca', 'Cb', 'Cc']
    >>> L=['Hello','World','I','Love']
    >>> [s.lower() for s in L]
    ['hello', 'world', 'i', 'love']
    >>> import os
    >>> [d for d in os.listdir('.')]
    ['.idlerc', '.PyCharm2017.1', '3D Objects',

（15）生成器（Generator）  
何谓生成器：  
答：一边循环一边计算的机制  
为什么要创建生成器：  
答：因为列表中元素太多，而我们却只访问少量元素，那就太浪费空间。我们通过一边循环一边计算出后续的元素，就不需要创建完整的列表；  
如何创建生成器：

>>> g = (x*x for x in range(1,11))
    >>> g
    <generator object <genexpr> at 0x0523EAD0>
    >>> g.next()
    1
    >>> g.next()
    4
    >>> g.next()
    9
    >>> for n in g:
    ...     print n
    ...
    16
    25
    36
    49
    64
    81
    100

(16) 迭代器  
1）迭代对象：例如list、tuple、dict、字符串等  
2）迭代器：可以被next()函数调用并不断返回下一个值得对象是迭代器（Iterator）  
备注：生成器都是迭代器（因为它课被next()函数调用，）  
凡是可作用于for（）都是可迭代对象；  
凡是可作用与next()都是迭代器。

>>> from collections import Iterator
    >>> from collections import Iterable
    >>> isinstance([],Iterable)
    True
    >>> isinstance([],Iterator)
    False
    >>> isinstance({},Iterable)
    True
    >>> isinstance({},Iterator)
    False
    >>> isinstance('abc',Iterable)
    True
    >>> isinstance('abc',Iterator)
    False
    >>> isinstance((x for x in range(10)),Iterable)
    True
    >>> isinstance((x for x in range(10)),Iterator)
    True

可以使用iter()函数将list、dict、str等可迭代对象变成迭代器：

>>> isinstance(iter([]),Iterator)
    True
    >>> isinstance(iter('abc'),Iterator)
    True

问题：为什么list、dict、str等不是迭代器呢？  
回答：因为Python得迭代器对象表示的是一个数据流，可以把这个数据流对象看作是一个有序序列，但不知道其长度，只能通过next()函数来计算下一个数据。因此迭代器对象是有惰性的。它可以表示无限大的数据流，而如list却不可以。