Python学习笔记(八)小知识点总结(1/2)

1. 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1

x = 4
y = 3
print((x > y) - (x < y))

2.返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。

import math

x = -3.1415926
print(math.modf(x))

3.print语句与字符串

var1 = 'Hello World!'

print(var1[0], var1[1], var1[2], var1[3], var1[4], var1[5], var1[6])
print(var1[1:7])

4.重复输出字符串(*)

例如:`print('a' * 3)`表示输出三个a

5.字符串获取与截取

相对于字符串hello
[]	通过索引获取字符串中字符	a[1] 输出结果 e
[ : ]	截取字符串中的一部分,遵循左闭右开原则,str[0,2] 是不包含第 3 个字符的。	a[1:4] 输出结果 ell

6.Python字符串格式化

print("我叫 %s 今年 %d 岁, 我的弟弟 %f 岁!" % ('小明', 10, 7.5))
输出:    我叫 小明 今年 10 岁, 我的弟弟 7.500000 岁!

7.Python三引号

三引号可以允许输入多行字符串,三引号让程序员从引号和特殊字符串的泥潭里面解脱出来,自始至终保持一小块字符串的格式是所谓的WYSIWYG(所见即所得)格式的。
一个典型的用例是,当你需要一块HTML或者SQL时,这时用字符串组合,特殊字符串转义将会非常的繁琐。

para_str = """这是Python一个实用的语法,避免了各种转义带来的困扰
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print(para_str)

例如:

errHTML = '''


    
          Friends CGI Demo
    


   

error

''' print(errHTML)

8.Python 的字符串内建函数

say = 'hello'
print(say.capitalize())
输出:Hello
首字母大写

s1 = 'help'
print(s1.center(100, '-'))
------------------------------------------------help------------------------------------------------
返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。

find(str, beg=0 end=len(string))
检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1

str.join(sequence)用于将序列中的元素以指定的字符连接生成一个新的字符串
    operator = '+'
    expression = ['x**x', 'y**y']
    result = 'r**r'
    print(operator.join(expression) + '=' + result)

lstrip()、rstrip()、strip()表示去除字符串中的空格,l=left, r=right

min(str)、max(str)表示返回字符串中最小/大字母。
如:print(min('apple')) , 则输出: a

str.swapcase()
print('Apple'.swapcase())
输出: aPPLE
将字符串中大写转换为小写,小写转换为大写,奇葩的函数

返回"标题化"的字符串,就是说所有单词都是以大写开始,其余字母均为小写(见 istitle())
print('apple or huawei ?'.title())
输出:Apple Or Huawei ?

str.upper() / str.lower() , 将字符串转换为大写或小写

9. Python序列

1、Python中序列的内置类型分别有哪些
Python内建的序列,有列表、元组、字符串(str、bytes)、buffer对象和 xrange 对象。(numpy中的array也是序列但不是python内建的序列,array与list的异同:array的数据项必须是同一类型,list可以不是)序列通用的操作包括:索引、长度、组合(序列相加)、重复(乘法)、分片、检查成员、遍历、最小值和最大值。

2、 列表和元组的异同:
Python有6个序列的内置类型,但最常见的是列表和元组。
列表和元组相似,具体包含下面几个方面:
相同点:
1、均具有序列的特性,均可以进行序列通用的操作;
2、通常均使用括号表示,且括号内的元素以逗号分隔值出现,数据项均不需要具有相同的类型;
3、均包含内置函数max、min、len;
4、均可以转换为对方;

异同点:
1、定义不同
1)列表使用方括号括起来的。
2)元组使用小括号括起来的。

2、是否可修改
1)列表可修改
2)元组不可修改

3、转换方式
1)列表转元组:tuple(seq)
2)元组转列表: list(seq)

4、是否含内置方法
1)列表提供11个内置方法list.append(obj)、list.count(obj)、list.extend(seq)、list.index(obj)、list.insert(index, obj)、list.pop([index=-1]])、list.remove(obj)、list.reverse()、list.sort(cmp=None, key=None, reverse=False)、list.clear()、list.copy();
2)元组未提供内置方法

【转载】内置序列类型概览
按照可否存储不同数据类型来分,可以分为容序列和扁平序列。

容器序列
list, tuple, collections.deque 这些序列类型可以容纳不同类型的数据。
扁平序列
str, bytes, bytearray, memoryview, array.array 这类序列只能容纳一种类型的数据
按照是否可变可以分为可变序列和不可变序列。

可变序列
list, bytesarray, array.array, collections.deque, memoryview
不可变序列
tuple, str, bytes
更多序列知识可参考:https://andrewpqc.github.io/2017/10/29/chapter-two-of-fluent-python/   

10. 交换两个变量的值Python写法

a,b=b,a

11. 双向队列

import collections
d = collections.deque()

常用方法:

  • append(往右边添加一个元素);
  • appendleft(往左边添加一个元素);
  • clear(清空队列)、copy(浅拷贝);
  • count(返回指定元素的出现次数);
  • extend(从队列右边扩展一个列表的元素);
  • extendleft(从队列左边扩展一个列表的元素);
  • index(查找某个元素的索引位置);
  • insert(在指定位置插入元素);
  • pop(获取最右边一个元素,并在队列中删除);
  • popleft(获取最左边一个元素,并在队列中删除);
  • remove(删除指定元素);
  • reverse(队列反转);
  • rotate(把右边元素放到左边)

详细用法见:双向队列

12. Python中不可变序列

详细见:序列不可变分析

13. List列表函数与方法(可对照deque去记忆)

Python列表函数&方法
Python包含以下函数:

序号 函数
1 len(list)
列表元素个数
2 max(list)
返回列表元素最大值
3 min(list)
返回列表元素最小值
4 list(seq)
将元组转换为列表
Python包含以下方法:

序号 方法
1 list.append(obj)
在列表末尾添加新的对象
2 list.count(obj)
统计某个元素在列表中出现的次数
3 list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
4 list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj)
将对象插入列表
6 list.pop([index=-1])
移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
7 list.remove(obj)
移除列表中某个值的第一个匹配项
8 list.reverse()
反向列表中元素
9 list.sort( key=None, reverse=False)
对原列表进行排序
10 list.clear()
清空列表
11 list.copy()
复制列表

14.元组

    空元组:tup = ()
    
    元组不用括号也可以
    
    tup1 = ('a', 'b', 'c', 'd',)
    tup2 = "a", "b", "c", "d",
    print(tup1, tup2)
    输出:('a', 'b', 'c', 'd') ('a', 'b', 'c', 'd')

元组中只包含一个元素时,需要在元素后面添加逗号,否则括号会被当作运算符使用:
如下所示: print(type((10))) 输出:; print(type((10, ))) 输出:

元组中的元素值是不允许修改的,但我们可以对元组进行连接组合或重新赋值操作
元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组

Python元组包含了以下内置函数:

  1. len(tuple) 计算元组元素个数。
  2. max(tuple) 返回元组中元素最大值。
  3. min(tuple) 返回元组中元素最小值。
  4. tuple(seq) 将列表转换为元组。

15. 字典的一些注意事项

  1. 键必须是唯一的,但值则不必。

  2. 值可以取任何数据类型,但键必须是不可变的,如字符串,数字或元组。
    举例如下:

     dict1 = {(20,): 3, (30,): 4, 'key1': 'value1', 2: 3, }
     print(dict1)
     输出: {(20,): 3, (30,): 4, 'key1': 'value1', 2: 3}
     其中:键取得值分别为元组、字符串、数字这些不可变对象
    
  3. 字典删除操作:包括del(删除某一项或整个字典)、pop(删除指定某一项,区别于del, pop删除后仍可以访问,如 item1 dict1.pop(‘key1’), 后面item1的值一直可用)、popitem(删除最后一项)

    dict1 = {(20,): 3, (30,): 4, 'key1': 'value1', 2: 3, }
    dict1.pop('key1')  删除的为指定的某一项
    dict1.popitem()    删除的为字典最后一项
    print(dict1)
    

16. 集合

集合(set)是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

下面展示两个集合间的运算.

a = set('abracadabra')
b = set('alacazam')
print(a)                                  
{'a', 'r', 'b', 'c', 'd'}
print( a - b)                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
print(a | b)                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
print(a & b)                              # 集合a和b中都包含了的元素
{'a', 'c'}
print(a ^ b)                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

类似列表推导式,同样集合支持集合推导式(Set comprehension):

a = {x for x in 'abracadabra' if x not in 'abc'}
print(a)
输出:{'r', 'd'}

集合内置方法完整列表
方法 描述

  1. add() 为集合添加元素
  2. clear() 移除集合中的所有元素
  3. copy() 拷贝一个集合
  4. difference() 返回多个集合的差集
  5. difference_update() 移除集合中的元素,该元素在指定的集合也存在。
  6. discard() 删除集合中指定的元素,且如果元素不存在,不会发生错误
  7. intersection() 返回集合的交集
  8. intersection_update() 删除集合中的元素,该元素在指定的集合中不存在。
  9. isdisjoint() 判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。
  10. issubset() 判断指定集合是否为该方法参数集合的子集。
  11. issuperset() 判断该方法的参数集合是否为指定集合的子集
  12. pop() 随机移除元素
  13. remove() 移除指定元素,如果元素不存在,则会发生错误。
  14. symmetric_difference() 返回两个集合中不重复的元素集合。
  15. symmetric_difference_update() 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中。
  16. union() 返回两个集合的并集
  17. update() 给集合添加元素

17. 循环

  1. while 循环使用 else 语句,在 while … else 在条件语句为 false 时执行 else 的语句块,循环语句可以有 else 子句,它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。

  2. 没有do…while这种语法

  3. Python pass是空语句,是为了保持程序结构的完整性。pass 不做任何事情,一般用做占位语句,如下实例

  4. for循环:同样也可以使用else语句块表示不满足for循环情况下执行的语句

                                for  in :
                                    
                               else:
                                    
    

两种方式遍历列表

a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']

for i, com in enumerate(a):
    print(i, com)


for i in range(len(a)):
    print(i, a[i])

18. 递归与迭代

  1. 在函数内部,调用函数自身的编程技巧称为递归( recursion)。递归函数结构清晰,很直观的理解计算过程,但也有严重缺点:相对于普通循环而言,递归运行效率较低,经过很多冗余的计算,递归会消耗大量的调用堆栈。在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个函数调用,栈就会加一层栈帧。每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,递归调用的次数过多,会导致栈溢出。因此,应该尽量用循环代替递归。
  2. 利用 for 循环来遍历一个列表(list)或元组(tuple),将值依次取出,这种方法我们称为迭代。 .
  3. 在 Python3 中,reduce() 函数已经被从全局名字空间里移除了,它现在被放置在 functools 模块里,如果想要使用它,则需要通过引入 functools 模块来调用 reduce() 函数:`
    reduce() 函数会对参数序列中元素进行累积。
    函数将一个数据集合(链表,元组等)中的所有数据进行下列操作:用传给 reduce 中的函数 function(有两个参数)先对集合中的第 1、2 个元素进行操作,得到的结果再与第三个数据用 function 函数运算,最后得到一个结果。
  4. 递归,简而言之就是应用程序自身调用自身,以实现层次数据结构的查询和访问。 递归的使用可以使代码更简洁清晰,可读性更好(对于初学者到不见得),但由于递归需要系统堆栈,所以空间消耗要比非递归代码要大很多,而且,如果递归深度太大,可能系统资源会不够用。

往往有这样的观点:能不用递归就不用递归,递归都可以用迭代来代替。

诚然,在理论上,递归和迭代在时间复杂度方面是等价的(在不考虑函数调用开销和函数调用产生的堆栈开销),但实际上递归确实效率比迭代低,既然这样,递归没有任何优势,那么是不是就,没有使用递归的必要了,那递归的存在有何意义呢?

万物的存在是需要时间的检验的,递归没有被历史所埋没,即有存在的理由。从理论上说,所有的递归函数都可以转换为迭代函数,反之亦然,然而代价通常都是比较高的。但从算法结构来说,递归声明的结构并不总能够转换为迭代结构,原因在于结构的引申本身属于递归的概念,用迭代的方法在设计初期根本无法实现,这就像动多态的东西并不总是可以用静多态的方法实现一样。这也是为什么在结构设计时,通常采用递归的方式而不是采用迭代的方式的原因,一个极典型的例子类似于链表,使用递归定义及其简单,但对于内存定义(数组方式)其定义及调用处理说明就变得很晦涩,尤其是在遇到环链、图、网格等问题时,使用迭代方式从描述到实现上都变得不现实。 因而可以从实际上说,所有的迭代可以转换为递归,但递归不一定可以转换为迭代。

采用递归算法需要的前提条件是,当且仅当一个存在预期的收敛时,才可采用递归算法,否则,就不能使用递归算法。

递归其实是方便了程序员难为了机器,递归可以通过数学公式很方便的转换为程序。其优点就是易理解,容易编程。但递归是用栈机制实现的,每深入一层,都要占去一块栈数据区域,对嵌套层数深的一些算法,递归会力不从心,空间上会以内存崩溃而告终,而且递归也带来了大量的函数调用,这也有许多额外的时间开销。所以在深度大时,它的时空性就不好了。

而迭代虽然效率高,运行时间只因循环次数增加而增加,没什么额外开销,空间上也没有什么增加,但缺点就是不容易理解,编写复杂问题时困难。

19. namedtuple

Python中的tuple大家应该都非常熟悉了。它可以存储一个Python对象序列。与list不同的是,你不能改变tuple中元素的值。tuple的元素是通过索引进行访问的:

fruits = ('apple', 'banana', 'orange')
print(fruits[0])
输出:apple

Tuple还有一个兄弟,叫namedtuple。虽然都是tuple,但是功能更为强大。对于namedtuple,你不必再通过索引值进行访问,你可以把它看做一个字典通过名字进行访问,只不过其中的值是不能改变的。

from collections import namedtuple

fruits_count = namedtuple('fruits_count', 'apple banana orange peach')
或者这样写:fruits_count = namedtuple('fruits_count', ['apple', 'banana', 'orange', 'peach'])
my_fruits_count = fruits_count(apple=200, banana=400, orange=400, peach=500)
print(my_fruits_count)
print('we need to buy %d apples and %d bananas' % (my_fruits_count.apple, my_fruits_count.banana), )

输出:fruits_count(apple=200, banana=400, orange=400, peach=500)
           we need to buy 200 apples and 400 bananas

为了构造一个namedtuple需要两个参数,分别是tuple的名字和其中域的名字。比如在上例中,tuple的名字是“fruits_count”,它包括四个域,分别是“apple”、“banana”和“orange”和‘peach’。

Namedtuple比普通tuple具有更好的可读性,可以使代码更易于维护。同时与字典相比,又更加的轻量和高效。但是有一点需要注意,就是namedtuple中的属性都是不可变的。任何尝试改变其属性值的操作都是非法的。

Namedtuple还有一个非常好的一点是,它与tuple是完全兼容的。也就是说,我们依然可以用索引去访问一个namedtuple。

20. Python命名规范

  1. 命名规范比较详细的介绍
  2. 以表格形式介绍命名规范
  3. 着重讲解以下划线命名的变量或函数

21. 函数的一些注意事项

  1. 在 python 中,类型属于对象,变量是没有类型的:

            a=[1,2,3]
            a="Runoob"
    

    以上代码中,[1,2,3] 是 List 类型,“Runoob” 是 String 类型,而变量 a 是没有类型,她仅仅是一个对象的引用(一个指针), 可以是指向 List 类型对象,也可以是指向 String 类型对象。

  2. 加了星号 * 的参数会以元组(tuple)的形式导入,存放所有未命名的变量参数。

  3. 加了两个星号 ** 的参数会以字典的形式导入。

  4. 声明函数时,参数中星号 * 可以单独出现,如果单独出现星号 * 后的参数必须用关键字传入。

  5. 匿名函数,python 使用 lambda 来创建匿名函数。所谓匿名,意即不再使用 def 语句这样标准的形式定义一个函数。
    lambda 只是一个表达式,函数体比 def 简单很多。
    lambda的主体是一个表达式,而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
    lambda 函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数。
    虽然lambda函数看起来只能写一行,却不等同于C或C++的内联函数,后者的目的是调用小函数时不占用栈内存从而增加运行效率。

    举例如下:

     def f(arg1, *args_tuple, **args_dict):
         """测试元组和字典作为参数传递"""
         print(arg1, args_tuple, args_dict)
     
     
     f(10, 15, 17, a='12', b=14, c=16)
     
     
     def fax(a, *, b, c, d):
         """测试*单独出现后面的参数都要用关键字传入"""
         print(a, b, c, d)
     
     
     fax(1, b=2, c=3, d=4)
     
     输出:
     10 (15, 17) {'a': '12', 'b': 14, 'c': 16}
     1 2 3 4
    
  6. 变量作用域
    Python 中,程序的变量并不是在哪个位置都可以访问的,访问权限决定于这个变量是在哪里赋值的。

变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种,分别是:

L (Local) 局部作用域
E (Enclosing) 闭包函数外的函数中
G (Global) 全局作用域
B (Built-in) 内置作用域(内置函数所在模块的范围)
以 L –> E –> G –>B 的规则查找,即:在局部找不到,便会去局部外的局部找(例如闭包),再找不到就会去全局找,再者去内置中找。

g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

内置作用域是通过一个名为 builtin 的标准模块来实现的,但是这个变量名自身并没有放入内置作用域内,所以必须导入这个文件才能够使用它。在Python3.0中,可以使用以下的代码来查看到底预定义了哪些变量:

  import builtins
  dir(builtins)

Python 中只有模块(module),类(class)以及函数(def、lambda)才会引入新的作用域,其它的代码块(如 if/elif/else/、try/except、for/while等)是不会引入新的作用域的,也就是说这些语句内定义的变量,外部也可以访问,如下代码:

 if True:
       msg = 'I am from Runoob'
输出: msg
'I am from Runoob'

实例中 msg 变量定义在 if 语句块中,但外部还是可以访问的。

如果将 msg 定义在函数中,则它就是局部变量,外部不能访问:

    def test():
         msg_inner = 'I am from Runoob'
    输出: msg_inner
    Traceback (most recent call last):
      File "", line 1, in 
    NameError: name 'msg_inner' is not defined 

从报错的信息上看,说明了 msg_inner 未定义,无法使用,因为它是局部变量,只有在函数内可以使用。

全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。

局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。如下实例:

实例(Python 3.0+)
#!/usr/bin/python3

total = 0 # 这是一个全局变量

可写函数说明

def sum( arg1, arg2 ):
    #返回2个参数的和."
    total = arg1 + arg2 # total在这里是局部变量.
    print ("函数内是局部变量 : ", total)
    return total
 
#调用sum函数
sum( 10, 20 )
print ("函数外是全局变量 : ", total)

以上实例输出结果:

函数内是局部变量 : 30
函数外是全局变量 : 0
global 和 nonlocal关键字
当内部作用域想修改外部作用域的变量时,就要用到global和nonlocal关键字了。

以下实例修改全局变量 num:

实例(Python 3.0+)

#!/usr/bin/python3
 
num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1()
print(num)

以上实例输出结果:

1
123
123
如果要修改嵌套作用域(enclosing 作用域,外层非全局作用域)中的变量则需要 nonlocal 关键字了,如下实例:

实例(Python 3.0+)

#!/usr/bin/python3
 
def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer()

以上实例输出结果:

100
100
另外有一种特殊情况,假设下面这段代码被运行:

实例(Python 3.0+)

#!/usr/bin/python3
 
a = 10
def test():
    a = a + 1
    print(a)
test()

以上程序执行,报错信息如下:

Traceback (most recent call last):
  File "test.py", line 7, in 
    test()
  File "test.py", line 5, in test
    a = a + 1

UnboundLocalError: local variable ‘a’ referenced before assignment
错误信息为局部作用域引用错误,因为 test 函数中的 a 使用的是局部,未定义,无法修改。

修改 a 为全局变量,通过函数参数传递,可以正常执行输出结果为:

实例(Python 3.0+)

#!/usr/bin/python3
 
a = 10
def test(a):
    a = a + 1
    print(a)
test(a)

执行输出结果为:

11

22. Python2与Python3中round使用的不同

python3中

round(0.5)
0
round(0.6)
1
round(1.5)
2
 round(2.5)
2
round(2.6)
3
round(3.5)
4
round(4.5)
4
round(5.5)
6
round(6.5)
6

可以简单的记忆为:整数部分为偶数时就舍去,为奇数时就进一,实际上是:如果距离两边一样远,会保留到偶数的一边(python文档中写的)

round(3.1415926, 2)
结果为:3.14
其中:第二个参数表示保留到第二位小数
更多详情可以查看:python3中round使用异常情况原因

23. 关于list的一些补充

    fruits = [1, 2, 3, '4', 5, ]
    vegetables = [10, 11, 13, 12, 14]
    
    fruits += vegetables
    fruits[len(fruits):] = vegetables
    fruits.extend(vegetables)
    上面三句是等效的都是把两个列表合并到一个列表中
    
    print(fruits)
    
    fruits.clear()
    del fruits
    
    1. clear与del还是不同的,一个是清空数据,另一个直接删除对象,删除后对象不能访问,清空后仍可访问
    2. 使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句从列表中删除一个切割,或 清空整个列表(我们以前介绍的方法是给该切割赋一个空列表)
    3. 如: del fruits[2:4]表示删除删除一个切片
    
    print(fruits)
    
    print(fruits.index(5))

  输出:
[1, 2, 3, '4', 5, 10, 11, 13, 12, 14]
[1, 2, 3, '4', 5, 10, 11, 13, 12, 14]
4

24. 推导式

注意三者的区别:

 1. 列表推导式:a = [x for x in range(5) if x < 4]                      结果为:[0,1,2,3]
 2. 集合推导式:a = {x for x in 'abracadabra' if x not in 'abc'}  结果为:{'r', 'd'}
 3. 字典推导式:a = {x: x**2 for x in (2, 4, 6)}                          结果为:{2: 4, 4: 16, 6: 36}
 
 补充:
 print([(x * y, x + y) for x, y in zip([1, 3, 5], [2, 4, 6]) if (x > 2 and y >= 4)])
 输出:[(12, 7), (30, 11)]
 说明:用zip可以实现遍历多个列表来使用推导式

25. 关于遍历的一些注意事项

1. 同时遍历两个或更多的序列,可以使用 zip() 组合:

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
     print('What is your {0}?  It is {1}.'.format(q, a))

输出:
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

2. 要反向遍历一个序列,首先指定这个序列,然后调用 reversed() 函数:

for i in reversed(range(1, 10, 2)):
    print(i)

输出:
9
7
5
3
1

3. 要按顺序遍历一个序列,使用 sorted() 函数返回一个已排序的序列,并不修改原值:

basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
for f in sorted(set(basket)):
     print(f)

输出:
apple
banana
orange
pear

26. 模块引入注意事项

  1. 一个模块被另一个程序第一次引入时,其主程序将运行。如果我们想在模块被引入时,模块中的某一程序块不执行,我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

  2. 说明: 每个模块都有一个__name__属性,当其值是’main’时,表明该模块自身在运行,否则是被引入。
    说明:namemain 底下是双下划线, _ _ 是这样去掉中间的那个空格。
    举例:

     if __name__ == '__main__':
        print('程序自身在运行')
     else:
        print('我来自另一模块')
     运行输出如下:
     
     $ python using_name.py
     程序自身在运行
    

27. 格式化输出 str.format()

Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。相对于老版的%格式方法,它有很多优点。

  1. 在%方法中%s只能替代字符串类型,而在format中不需要理会数据类型;
  2. 单个参数可以多次输出,参数顺序可以不相同;
  3. 填充方式十分灵活,对齐方式十分强大;
  4. 官方推荐用的方式,%方式将会在后面的版本被淘汰。

使用如下:

1、按照默认顺序,不指定位置

print("{} {}".format("hello","world") )
输出:hello world

2、设置指定位置,可以多次使用

print("{0} {1} {0}".format("hello","or"))
输出:hello or hello

3、使用列表格式化

person = {"name":"kingspacing","age":20}
print("My name is {name} . I am {age} years old .".format(**person))
输出: My name is kingspacing. I am 20 years old .

或者字典格式化:

table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
上面两种方式等效
输出: Runoob: 2; Google: 1; Taobao: 3

4、通过列表格式化

stu = ["kingspacing","linux","MySQL","Python"]
print("My name is {0[0]} , I love {0[1]} !".format(stu))
输出:My name is kingspacing, I love linux !

数字格式化
数字 格式 输出 描述

3.1415926 {:.2f} 3.14 保留小数点后两位

3.1415926 {:+.2f} +3.14 带符号保留小数点后两位

-1 {:+.2f} -1.00 带符号保留小数点后两位

2.71828 {:.0f} 3 不带小数

5 {:0>2d} 05 数字补零 (填充左边, 宽度为2)

5 {:x<4d} 5xxx 数字补x (填充右边, 宽度为4)

10 {:x<4d} 10xx 数字补x (填充右边, 宽度为4)

1000000 {:,} 1,000,000 以逗号分隔的数字格式

0.25 {:.2%} 25.00% 百分比格式

1000000000 {:.2e} 1.00e+09 指数记法

13 {:10d} 13 右对齐 (默认, 宽度为10)

13 {:<10d} 13 左对齐 (宽度为10)

13 {:^10d} 13 中间对齐 (宽度为10)

进制转换

         11 '{:b}'.format(11) 1011 二进制    
         11 '{:d}'.format(11) 11 十进制
         11 '{:o}'.format(11) 13 八进制
         11 '{:x}'.format(11) b 十六进制
         11 '{:#x}'.format(11) 0xb 十六进制
         11 '{:#X}'.format(11) 0XB 十六进制

^, <, > 分别是居中、左对齐、右对齐,后面带宽度, : 号后面带填充的字符,只能是一个字符,不指定则默认是用空格填充。
+ 表示在正数前显示 +,负数前显示 -; (空格)表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

输出大括号

print("{} {{0}}".format("kingspacing_linux"))
输出:kingspacing_linux {0}

28. 类的一些注意事项

  1. self代表类的实例,而非类
  2. 类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。
  3. self 不是 python 关键字, 可以换成其他名称
  4. Python 同样支持类的继承,需要注意圆括号中基类的顺序,若是基类中有相同的方法名,而在子类使用时未指定,python从左至右搜索 即方法在子类中未找到时,从左到右查找基类中是否包含方法。
  5. Python同样支持运算符重载,我们可以对类的专有方法进行重载
  6. 类的专有方法:
    init : 构造函数,在生成对象时调用
    del : 析构函数,释放对象时使用
    repr : 打印,转换
    setitem : 按照索引赋值
    getitem: 按照索引获取值
    len: 获得长度
    cmp: 比较运算
    call: 函数调用
    add: 加运算
    sub: 减运算
    mul: 乘运算
    truediv: 除运算
    mod: 求余运算
    pow: 乘方

29. Python3 标准库概览

  1. os模块提供了不少与操作系统相关联的函数。
  2. 建议使用 “import os” 风格而非 “from os import *”。这样可以保证随操作系统不同而有所变化的 os.open() 不会覆盖内置函数 open()。
  3. 针对日常的文件和目录管理任务,:mod:shutil 模块提供了一个易于使用的高级接口:
  4. glob模块提供了一个函数用于从目录通配符搜索中生成文件列表:

30. python基础----特性(property)、静态方法(staticmethod)、类方法(classmethod)、__str__的用法

  1. 非常详细的讲解
  2. 图文并茂的解释,也值得学习

你可能感兴趣的:(python)