PYTHON 学习笔记

最新推荐文章于 2022-11-21 18:37:21 发布

Nihil_

最新推荐文章于 2022-11-21 18:37:21 发布

阅读量238

点赞数

分类专栏： PYTHON

本文链接：https://blog.csdn.net/zhoujm2/article/details/81108179

版权

PYTHON 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

版本：vs.18.7.21.3
这是由zhoujm整理得到，关注：

头条号: 隽科技

Contents
PYTHON 学习笔记

PYTHON 学习笔记

1. 字符串

1.1 替换字段名

>>> "{foo} {} {bar} {}".format(1, 2, bar=4, foo=3) 12 '3 1 4 2'
>>> ///结果如下
>>> '3 1 4 2'

在替换字段名的时候，同时可以应用索引，如下面所示：

>>> fullname = ["Alfred", "Smoketoomuch"]
>>> "Mr {name[1]}".format(name=fullname) 
'Mr Smoketoomuch'

对于类之中的对象的字段名的替换例子如下：

>>> import math
>>> tmpl = "The {mod.__name__} module defines the value {mod.pi} for π" 
>>> tmpl.format(mod=math)
'The math module defines the value 3.141592653589793 for π'

在这个例子当中，__name__的对象为pi，并且在math的大类当中。

1.2 基本转换

直接用例子说话：

>>> print("{pi!s} {pi!r} {pi!a}".format(pi="π")) 
π 'π' '\u03c0'

s，r，a分别是str，repr和ASCII。

对数据进行处理的另一个例子：

>>> "The number is {num}".format(num=42)
'The number is 42'
>>> "The number is {num:f}".format(num=42) 
'The number is 42.000000'
>>> "The number is {num:b}".format(num=42) 
'The number is 101010'

Detail: you can add this like

>>> 'One googol is {:,}'.format(10**100)
'One googol is 10,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,00 0,000,000,000,000,000,000,000,000,000,000,000,000,000,000'

具体格式对应：
< -> 右对齐
> -> 左对齐
^ -> 居中对齐
例子又来了：

>>> print('{0:<10.2f}\n{0:^10.2f}\n{0:>10.2f}'.format(pi)) 
3.14
     3.14
            3.14

其他重要元素

+,-
#(为数据进制加上前缀)

1.3 字符串方法

1.3.1 center

居中作用

>>> "The Middle by Jimmy Eat World".center(39)
'     The Middle by Jimmy Eat World     '
>>> "The Middle by Jimmy Eat World".center(39, "*") 
'*****The Middle by Jimmy Eat World*****'

1.3.2 find

在字符串当中寻找子串。如果找到，就返回子串的第一个字符的索引，否则返回-1。并且find方法是可以设置起始的.find('',begin,end)

1.3.3 join

合并序列：
target.join(list)

>>> seq = [1, 2, 3, 4, 5]
>>> sep = '+'
>>> sep.join(seq) 
/// 尝试合并一个数字列表 
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: sequence item 0: expected string, int found 
>>> seq = ['1', '2', '3', '4', '5']
>>> sep.join(seq) 
/// 合并一个字符串列表
'1+2+3+4+5'
>>> dirs = '', 'usr', 'bin', 'env'
>>> '/'.join(dirs)
'/usr/bin/env'
>>> print('C:' + '\\'.join(dirs))
C:\usr\bin\env

1.3.4 lower

这个简单，略略略

1.3.4.1词首大写

这个方法在模块string中。

>>> import string
>>> string.capwords("that's all , folks")
That's All, Folks

1.3.5 replace

'string'.replace('a','b')

1.3.6 split

'string'.split('target')

1.3.7 strip

删除字符串首位空白并返回
.strip()

2. 当索引行不通时

2.1 字典

表达方式：
phonebook = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

2.1.1 函数dict

可使用函数dict从其他映射(如其他字典)或键值对序列创建字典。

>>> items = [('name', 'Gumby'), ('age', 42)] >>> d = dict(items)
>>> d
{'age': 42, 'name': 'Gumby'}
>>> d['name'] 
'Gumby'

2.1.2 字典的基本操作与方法

常见：
len(),d[k],d[k] = v
del d[k] delete the key which named as k.
k in d check if the k (key) is in the d (dictionary) .

下面是一个制作并访问电话簿的例子：

people = {
    'Alice': {
        'phone': '2341',
        'addr': 'Foo drive 23' },
    'Beth': {
        'phone': '9102',
        'addr': 'Bar street 42' }
}
#_this is a label_
labels = {
         'phone': 'phone number',
         'addr': 'address' }
name = input('Name: ')
request = input('Phone number (p) or address (a)? ')
if request == 'a': key = 'addr'
if request == 'p': key = 'phone'
if name in people: print("{}'s {} is {}.".format(name, labels[key], people[name][key]))

Format_map

>>> phonebook
{'Beth': '9102', 'Alice': '2341', 'Cecil': '3258'}
>>> "Cecil's phone number is {Cecil}.".format_map(phonebook) 
"Cecil's phone number is 3258."

2.1.3 字典方法

method	How does it work	example
1.clear	delete all units	d.clear()
2.copy/deepcopy	copy the dict	d.copy()/d.deepcopy()
3.fromkeys	create a new dict that contains all the keys you need(the value of each one is None)	d.fromkeys([ ])
4.get	get unit without crash	d.get( 'xx','None')
5.item	return a list contains all items	d.item()
6. keys	return a dict map	d.keys()
7.pop	as you know	d.pop()
8. popitem	as you know	d.popitem()

这里再介绍三个方法：

setdefault:这个方法类似get，在判断结束的时候，会在dict当中加上没有的item
update:使用一个字典里的项目来更新另一个字典的项目
value:返回字典视图，返回相同值。

3. 语句

3.1再谈print和import

打印多组数据不换行 print("string",end=' ')
导入模块重命名 from module1 import open as open1 , from module2 import open as open2
序列解包

>>> a, b, *rest = [1, 2, 3, 4] 
>>> rest
[3, 4]

*号也可以放在其他位置

链式赋值
增强赋值

3.2 条件和条件语句

布尔值为假：
False,None, 0,"",(),[],{}
Key words
is,in

3.3 循环语句

while
for

key words
range()
for语句同时可以遍历字典

3.3.1迭代

并行迭代
迭代时索引

例子又来了

for string in strings:
    if 'xxx' in string:
        index = strings.index(string) 
        strings[index] = '[censored]'

追踪迭代
for index, string in enumerate(strings):

3.3.2 跳出循环

break
continu:直接开始下一次迭代
pass:啥都不干
del: delete

3.4 使用exec和eval执行字符串及计算结果

exec 函数exec将字符串作为代码执行。

>>> exec("print('Hello, world!')")
Hello, world!

然而，调用函数exec时只给它提供一个参数绝非好事。在大多数情况下，还应向它传递一个命名空间——用于放置变量的地方;否则代码将污染你的命名空间，即修改你的变量。例如，假设代码使用了名称sqrt，结果将如何呢?

>>> from math import sqrt
>>> exec("sqrt = 1")
>>> sqrt(4)
Traceback (most recent call last):
File "<pyshell#18>", line 1, in ? sqrt(4)
TypeError: object is not callable: 1

既然如此，为何要将字符串作为代码执行呢?函数exec主要用于动态地创建代码字符串。如果这种字符串来自其他地方(可能是用户)，就几乎无法确定它将包含什么内容。因此为了安全起见，要提供一个字典以充当命名空间。为此，你添加第二个参数—字典，用作代码字符串的命名空间

>>> from math import sqrt
>>> scope = {}
>>> exec('sqrt = 1', scope)
>>> sqrt(4)
2.0
>>> scope['sqrt'] 1

eval是一个类似于exec的内置函数。exec执行一系列Python语句，而eval计算用字符串表示的Python表达式的值，并返回结果(exec什么都不返回，因为它本身是条语句)。例如，你可使用如下代码来创建一个Python计算器:

>>> eval(input("Enter an arithmetic expression: ")) 
Enter an arithmetic expression: 6 + 18 * 2
42

4. 抽象（懒惰是一种美德）

4.1定义函数

def hello(name):
    return 'Hello, ' + name + '!'

运行这些代码后，将有一个名为hello的新函数。它返回一个字符串，其中包含向唯一参数指定的人发出的问候语。你可像使用内置函数那样使用这个函数。

>>> print(hello('world')) 
Hello, world!
>>> print(hello('Gumby')) 
Hello, Gumby!

很不错吧?如果编写一个函数，返回一个由斐波那契数组成的列表呢?很容易!只需使用前面介绍的代码，但不从用户那里读取数字，而是通过参数来获取。

def fibs(num):  
    result = [0, 1]
    for i in range(num-2): 
            result.append(result[-2] + result[-1])
    return result

执行这些代码后，解释器就知道如何计算斐波那契数了。现在你不用再关心这些细节，而只需调用函数fibs。
在这个示例中，num和result也可以使用其他名字，但return语句非常重要。return语句用于从函数返回值(在前面的hello函数中，return语句的作用也是一样的)。

4.2 给函数编写文档

要给函数编写文档，以确保其他人能够理解，可添加注释(以#打头的内容)。还有另一种编写注释的方式，就是添加独立的字符串。在有些地方，如def语句后面(以及模块和类的开头，这将在第7章和第10章详细介绍)，添加这样的字符串很有用。放在函数开头的字符串称为文档字符串(docstring)，将作为函数的一部分存储起来。下面的代码演示了如何给函数添加文档字符串:

def square(x):
    'Calculates the square of the number x.'    
    return x * x

可以像下面这样访问文档字符串:

>>> square.__doc__
'Calculates the square of the number x.'

顺带
函数help

4.3 参数魔法

字符串(以及数和元组)是immutable的，这意味着你不能修改它们(即只能替换为新值)。因此这些类型作为参数没什么可说的。

如果参数是不可变的

在有些语言(如C++、Pascal和Ada)中，经常需要给参数赋值并让这种修改影响函数外部的变量。在Python中，没法直接这样做，只能修改参数对象本身。但如果参数是不可变的(如数)呢? 不好意思，没办法。在这种情况下，应从函数返回所有需要的值(如果需要返回多个值，就
以元组的方式返回它们)。例如，可以像下面这样编写将变量的值加1的函数:

>>> def inc(x):return x + 1
...
>>> foo = 10
>>> foo = inc(foo)
>>> foo 
11

或者使用global转为全局变量使用。

良好的关键字参数习惯

虽然这样做的输入量多些，但每个参数的作用清晰明了。另外，参数的顺序错了也没关系。
然而，关键字参数最大的优点在于，可以指定默认值。

def hello_3(greeting='Hello', name='world'):
    print('{}, {}!'.format(greeting, name))

收集参数

def print_params(*params): 
    print(params)

这样的函数中*号代表将所有的参数都收集到同一个tuple当中。同时也可以有多个元素的输入，*就代表将剩下的参数收集到tuple当中。
例外：当函数定义的时候*号所在位置为中间某个值的话，在调用函数的时候需要将*之后的参数进行一一对应。

WANING:*是不会收集关键字参数的。
如果是需要收集关键字参数的话，**可以做到。同时，这样的方法是将关键字参数储存到字典当中。

分配参数

*同时可以将参数从tuple当中分配出来执行相应的函数。

def add(x, y): 
    return x + y
params = (1, 2)
_______________________
>>> add(*params)
3

字典同理。

4.4 作用域

Tip:
Vars()函数返回内部指针字典。
在局部，局部变量优先程度大于全局变量。

函数的嵌套

def multiplier(factor):
    def multiplyByFactor(number):
        return number * factor 
    return multiplyByFactor

在这里，一个函数位于另一个函数中，且外面的函数返回里面的函数。也就是返回一个函数，而不是调用它。重要的是，返回的函数能够访问其定义所在的作用域。换而言之，它携带着自己所在的环境(和相关的局部变量)!

函数的闭包：

>>> double = multiplier(2)
>>> double(5)
10
>>> mutiplier(4)(5)
20

函数的递归：
简单地说，递归意味着引用自身。

二分查找算法：

def search(sequence, number, lower, upper): 
    if lower == upper:
        assert number == sequence[upper]
        return upper 
    else:
        middle = (lower + upper) // 2 
        if number > sequence[middle]:
            return search(sequence, number, middle + 1, upper) 
        else:
            return search(sequence, number, lower, middle)

5. 对象

多态
封装
继承

5.1 介绍

5.1.1 多态

很多函数和运算符都是多态的，你编写的大多数函数也可能如此，即便你不是有意为之。每当你使用多态的函数和运算符时，多态都将发挥作用。

5.1.2 封装

封装(encapsulation)指的是向外部隐藏不必要的细节。这听起来有点像多态(无需知道对象的内部细节就可使用它)。这两个概念很像，因为它们都是抽象的原则。它们都像函数一样，可帮助你处理程序的组成部分，让你无需关心不必要的细节。

5.1.3 继承

继承是另一种偷懒的方式。我们总是想避免多次输入同样的代码。前面通过创建函数来达成这个目标，但现在要解决一个更微妙的问题。如果你已经有了一个类，并要创建一个与之很像的类(可能只是新增了几个方法)，该如何办呢?创建这个新类时，你不想复制旧类的代码，将其粘贴到新类中。

5.2 类

创建类

class Person:
    def set_name(self,name):
            self.name = name
    def set_name(self):
        return self.name
    def greet(self):
        print("hey, I am {}.".format(self.name))