python学习记录

环境

以前用的都是 python 3 的版本，可是无奈公司要 2.7 版本，我都是用 anaconda 装的，那么就只能在 anaconda 里头配置一下了，其实很简单，参考这篇博客：
https://blog.csdn.net/levon2018/article/details/84316088

下面内容完全转载的上面的博客，为啥要重新写一遍呢，是因为发现和博主的情况有点出入，activate 在 anaconda 下的命令应该是 conda activate 文件夹名，所以我重新记录一下：

0、我是在这里头打开的：

1、首先确保你的系统里已经安装了Conda，打开命令行窗口，执行命令：conda --version

2、查看你的系统当前已有的Python环境，执行命令：conda info --envs，从图中我们看到，我的机器里目前只有安装Anaconda时创建的默认Python环境，环境名称叫root，对应的Python版本是3.7

3、现在，我想添加一个Python2.7的环境，执行命令：conda create --name python27 python=2.7，命令中我制定了环境名称是python27，指定了Python版本是2.7，执行命令后，Conda会自动下载最新版的Python2.7，并自动部署

4、此时，再次查看你的系统当前已有的Python环境，执行命令：conda info --envs，从图中我们看到，这里多了一个名字为python27的Python环境

5、查看我们当前使用的Python版本，执行命令：python --version，从图中看到当前的Python环境是3.7版本

6、切换Python环境到刚才新添加的Python2.7，执行命令：conda activate python27，然后执行命令：python --version，查看是否切换成功

上图是我配置的情况，可以看到用没有带 conda 就没有切换成功。

7、在Python27环境下，完成工作后，切回原来的Python环境，执行命令：deactivate python27 或 activate base 两个都可以

8、如果刚才添加的Python27环境，不再使用，可通过执行命令：conda remove --name python27 --all，进行删除

关于 Anaconda

1. WARNING: Retrying (Retry(total=4, connect=None, read=None, redirect=None, status=None)) 问题

https://blog.csdn.net/thenorther/article/details/104376561

Windows控制台

https://blog.csdn.net/qq754772661/article/details/106996236/

wsl2 下 python2.7 安装

wsl2测试一些小程序蛮方便的，默认装的python3.8：

装一下 python2.7，使用命令：sudo apt install python

然后就能直接输入python用于测试了：

输入 python3 则是进入 python3 解释器下的测试：

用ctrl + D 或者 exit() 来退出python环境

ide 与 安装包

python有自己的包管理系统，方便的一批。

这里我用 pycharm，python 解释器在 file->settings->Project->Python Interpreter


我们可以在anaconda中安装所需要的包，比如我想测试一下numpy：

import numpy as np
a = np.arange(10)
print(a)

没有装numpy会报错，因为在对应解释器的环境中找不到这个包，所以要在对应环境中安装，在anaconda中用对应指令： conda install -n python27 numpy

这里的 -n python27 就是指定环境是 python27 的意思，python27 是我们在第一步安装 python2.7 的对应环境。

貌似也可以在这里很方便地安装包：

学习记录

一切皆对象

Python 中一切皆对象，这个对象不是面向对象中的对象，这个object指的是python内存管理模式。它们本质上就是 C 中的 malloc 为结构体实例在堆区申请的一块内存。它们本质上就是 C 中的 malloc 为结构体实例在堆区申请的一块内存
参考：https://www.zhihu.com/question/445389789/answer/1748850468、https://zhuanlan.zhihu.com/p/351346168

字符串

• 不分单双引号，括起来的都是字符串，所以可以在双引号中间包着单引号也能正确当作一个字符串（或单引号包起来的字符串中有双引号）
• title()：首字母大写
• upper()：全大写
• lower()：全小写
• rstrip()：删除字符串末尾的空白（空白可以是空格、制表符和换行符）
• lstrip()：删除字符串开头的空白（空白可以是空格、制表符和换行符）
• rstrip()：删除字符串两端的空白（空白可以是空格、制表符和换行符）

import this

这个2和3输出结果都是一样的：

Python 2.7.18 (default, Mar  8 2021, 13:02:45)
[GCC 9.3.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 3 / 2
1
>>> 3.0 / 2
1.5
>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
>>>

列表

像一个栈。

常用方法：

• 添加删除：
  append、insert、del、pop、remove

a = [0, 0, 0, 1, 2, 3, "22", '4']
print(a)
a.remove(0)
print(a)
a.append("5")
print(a)
del a[0]
print(a)
a.insert(0, 1)
print(a)
b = a.pop()
c = a.pop(0)
print(b, c)

打印结果：
[0, 0, 0, 1, 2, 3, '22', '4']
[0, 0, 1, 2, 3, '22', '4']
[0, 0, 1, 2, 3, '22', '4', '5']
[0, 1, 2, 3, '22', '4', '5']
[1, 0, 1, 2, 3, '22', '4', '5']
('5', 1)

remove只删除第一个值，如果要全删则需要循环。

• 其他方法：
  sort() 排序，sorted() 临时排序（不修改原列表，可传递参数 reverse=True），reverse() 反转顺序，len() 列表长度

• 列表解析：

a = [value ** 2 for value in range(0, 11)]
print(a)

打印结果：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

• 检查在不在列表里

a = (0, 1, 2, 3)
print('hbh' in a)
print('hbh' not in a)
b = True
c = 'hbh' not in a
if b == c:
    print("Yes!")

打印结果：
False
True
Yes!

可以看到，上面代码的 b 和 c 都是 bool 表达式。

• 补充
  访问最后一个元素可以直接用索引 -1. python中索引可为负数。

列表切片

列表a，a[起始索引(默认为0位置，即从头开始) : 终止索引(默认为-1后面的位置，即到结尾为止)]

a = [value ** 2 for value in range(0, 11)]
print(a[:]) # 和 print(a) 一样
print(a[-3:])
print(a[0:0])
print(a[0:1])

打印结果：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[64, 81, 100]
[]
[0]

列表的深拷贝必须用切片：

a = [value ** 2 for value in range(0, 11)]
b = a  # 浅复制，此时a和b指向同一块
c = a[:]  # 深复制
a.append("hbh")
print(a)
print(b)
print(c)

打印结果：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 'hbh']
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 'hbh']
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

元组

列表非常适合用于存储在程序运行期间可能变化的数据集。即列表可以修改。

然而有时候需要创建一系列不可修改的元素，python将不能修改的值称为 不可变的 。不可变的列表被称为元组。用圆括号包起来。

注意，元组本身是不可变的，但是元组变量是可变的：

a = (0, 1, 2, 3)
# a[0] = 1 ，报错！ TypeError: 'tuple' object does not support item assignment
a = (1, 2, 3, 4)
print(a)

打印结果：
(1, 2, 3, 4)

相比列表，元组是更简单的数据结构。如果需要存储的一组值在程序的整个生命周期内都不变，可使用元组。

字典

大括号，键值对。

a = {}
if not a:
    a['hbh'] = '帅哥'
    print("我是一个" + str(a['hbh']))
else:
    print("???")
a['ysy'] = '美女'
del a['hbh']
print('')
for key, value in a.items():
    print(str(key) + "是" + str(value))

打印结果：
我是一个帅哥

ysy是美女

删除同样用 del，这里遍历键值对用了 items() 方法，它返回一个键值对列表。

方法：

• items()：返回一个键值对列表。
• keys()：返回所有的键列表。如果需要排序可以在前面加个 sorted
• values()：返回所有的值列表。如果需要查重则可以用set包起来。

字典、列表、元组这些容器都可以互相嵌套。

函数

Python 官方文档中的一段说明：

“Remember that arguments are passed by assignment in Python. Since assignment just creates references to objects, there’s no alias between an argument name in the caller and callee, and so no call-by-reference per Se.”

准确地说，Python 的参数传递是赋值传递 （pass by assignment），或者叫作对象的引用传递（pass by object reference）。Python 里所有的数据类型都是对象，所以参数传递时，只是让新变量与原变量指向相同的对象而已，并不存在值传递或是引用传递一说。

示例代码：

def test(name_list, b_print=False):
    if b_print:
        for name in name_list:
            print(name)
    name_list.append('hbh2')


a = ['hbh', 'ysy']
test(a, b_print=True)
print(a)

打印结果：
hbh
ysy
['hbh', 'ysy', 'hbh2']

可以看到，由于传递的是列表，在函数里头会指向同一个列表，因此函数内部也会修改这个列表。若是不想这样，可以传递切片：test(a[:])

传递任意数量的实参 ：

一个 * 让Python创建一个空元组，收到的值会存进来：

def test(*name_list):
    for name in name_list:
        print(name)


test('hbh', 'ysy', 'hbh2', 'ysy2')

两个 * 让Python创建一个空字典，收到的值会存进来：

def test(**name_dictionary):
    for key, value in name_dictionary.items():
        print(str(key) + " : " + str(value))


test(hbh='shuai', ysy='mei')

打印结果：
ysy : mei
hbh : shuai

并且既然一切皆对象，我们可以对函数也赋给一个变量（甚至函数内部还能定义、返回一个函数）：

def hi(name="yasoob"):
    return "hi " + name


print(hi())
# output: 'hi yasoob'

greet = 'hbh'
greet = hi

print(greet())
# output: 'hi yasoob'

del hi

print(greet())
# outputs: 'hi yasoob'

可以看到即使 del 了 hi ，但是之前已经赋给了 greet ，所以使用 greet 也没事。

参考：https://www.runoob.com/w3cnote/python-func-decorators.html

导入模块

大致就这几种：（这里假设有一个 module_name.py，里头写了一个函数 function_name）

import module_name
from module_name import function_name
import module_name as mn
from module_name import function_name as fn
from module_name import *

除了函数，也可以导入模块里头的类，是一样的。

类

一些tips：

比如 __init__(self, ...)，这是一种特殊的方法，每当创建实例的时候python会自动运行它。开头结尾的两个下划线，是一种约定，旨在避免python默认方法与普通方法发生名称冲突。

继承时候初始化语法在2.7和3版本中的语法不同。将在后面的对比中讲。

类中的每个属性都必须有初始值，哪怕是 0 或空字符串。

装饰器

参考：https://www.runoob.com/w3cnote/python-func-decorators.html

def my_decorator(my_func):
    def wrapTheFunction():
        print("before executing my_func()")
        my_func()
        print("after executing my_func()")
    return wrapTheFunction


@my_decorator
def my_print():
    print("doing......")


my_print()
print(my_print.__name__)

打印结果：
before executing my_func()
doing......
after executing my_func()
wrapTheFunction

其实装饰器就相当于 my_print = my_decorator(my_print)，但是由于 my_decorator 返回的是 wrapTheFunction 函数，所以打印my_print的名字的时候就变成了 wrapTheFunction ，这非常不好，我们可以用 functools.wraps 去修正：

from functools import wraps


def my_decorator(my_func):
    @wraps(my_func)
    def wrapTheFunction():
        print("before executing my_func()")
        my_func()
        print("after executing my_func()")
    return wrapTheFunction


@my_decorator
def my_print():
    print("doing......")


my_print()
print(my_print.__name__)

打印结果：
before executing my_func()
doing......
after executing my_func()
my_print

文件读写

读取文本文件时，Python将其中的所有文本都解读为字符串。

with open('test.txt') as file_object:
    contents = file_object.read()
    print(type(contents))
    print(contents.rstrip())

执行知道，这个文件是 ，即 str 类型的。with 是一个关键字，让 Python 确定合适关闭文件。自己管理则是 open 和 close，不加以管理则有内存泄漏的风险。但是这里的 file_object 只能在with代码块内有效，要是想在代码块用需要搬移到一个新的列表中。

open参数：读取模式 r ，写入模式 w ，附加模式 a ，读写模式 r+ ，默认为 r 。

之后可以用 .write(‘…’) 写入内容。写入模式下应该是覆盖，附加模式下则是添加到文件末尾。

异常

try-except-else：可能抛异常的代码放入 try ，处理异常的代码放入 except ，try 代码成功执行时才需要运行的代码放入else。

有时候希望在失败的时候什么也不做，所以弄出个 pass：

try:
	...
except xxxError:
    pass
else:
    ...

pass 充当一个占位符，提醒程序在这里什么也没做，并且以后可能要在这里做些什么。

设置代码格式

Python改进提案（Python Enhancement Proposal，PEP）。PEP8 是最古老的PEP之一。网址：https://www.python.org/dev/peps/

PEP 8 建议每级缩进都使用四个空格。

混合使用制表符和空格会让python解释器感到迷惑。 每款文本编辑器都提供了一种设置，可将输入的制表符转换为指定数量的空格。因此要用制表符最好对编辑器进行设置，使其在文档中插入空格而不是制表符。

如 pycharm 默认就设置好了，在这个地方：

pycharm显示空格：

在程序中混合使用制表符和空格可能导致极难解决的问题。如果你混合使用了制表符和空格，可将文件中所有的制表符转换为空格，大多数编辑器都提供了这样的功能。

PEP 8 还建议注释的行长不超过 72 字符。

类中的函数只需要一行空行，比如这里pycharm提示我 PEP 8 的建议：

python2 和 python3 的一些区别

可参考：https://www.runoob.com/python/python-2x-3x.html

1. print

python2 中 print 后甚至可以不加括号：print "hello"，当然也能加；而3中的print是一个函数，就必须要加括号。（2.7中print则是关键字）

2. 除法，python2 中整数除法只包含整数部分

3. input

可参考：https://www.runoob.com/python/python-func-input.html

python2 中 input 相等于 eval(raw_input(prompt)) ，用来获取控制台的输入。raw_input 才是输入字符串。
python3 中 input 输入的都视为字符串，要想当数值还需要用 int() 去转。

如上图，我在 2.7 版本中input输入了之前的变量 Str，相当于把这个值存进了b中，除了输入Str还能直接输入一个数值，会被当作数值保存进b中：

4. 类

参考：https://www.zhihu.com/question/19754936/answer/202650790

直接建议基类都继承一下 object。

继承的时候也有区别：

class A(object):
    def __init__(self, name):
        self.name = name


class B(A):
    def __init__(self, name):
        super(B, self).__init__(name)
        # python3: super().__init__(name)

pycharm 快捷键

shift + f10：运行
双击 shift：查找
Alt + shift + Ins：列模式

列模式下再用 shift 就能很方便地操作。

显示空格和tab