python - 官方简易文档篇（1）常用、函数

Python Tutorial, 发布 3.8.4rc1 tutorial.pdf

刚总结完str的一些细节，其中还有很多关于类的自定义的因为没有接触过，所以还不知道如何去用，但是再菜鸟教程上看到一个python的文档，大致是python html版文档的内容，而且我发现，在官方的library中，并没有while等，于是，我现在从Tutorial开始翻，这算是一个轻量级较全面的文档，过一遍后，再啃书，啃烦了，再看看这三篇中哪些内容可以继续看了！

调用python

在windows下，可以直接双击程序打开python，也可以用win+r或者在cmd下运行，或者运行快捷方式、批处理、脚本等。
在linux下可以运行程序、脚本、shell中运行命令。

启动方式中是可以加命令的，例如： python -c command [arg] …

这些命令会被python接收并存储在sys模块的argv变量中，进而进一步处理、运行！

终端、控制台、tty、shell等区别与概念初辨析

使用python

shell下，可以输入并运行一些短小的代码，当运行多行的代码时，可以在行末输入""，在""“三引号后可以不用加”"直接回车

>>> print("wang \
... 1")
wang 1
>>> print("""wang
... 1""")
wang
1

源文件的字符编码

默认情况，python是以UTF-8进行编码的，而其实目前支持的是unicode的UCS-4规格，即字符范围是0~10FFFF

如果不使用默认编码，要声明文件所使用的编码，文件的第一行注释编码！

# -*- coding: encoding -*- #
#以上是写法规则 

# -*- coding: cp1252 -*- #
#以上是案例，代码将以cp1252的编码存在于内存？和硬盘中

#!/usr/bin/env python3
# -*- coding: cp1252 -*-
#以上是unix环境下，添加了这个命令后，就和windows下一样直接运行，否则就是打开一个文本而已（大概）

tab 补全函数、变量
方向键上下，重复上一条代码

批量注释

# 注释语句
在jupyter中，可以使用ctrl+/批量注释选中的语句
网上有使用
“”"
…
…
“”"
这种三引号批量注释多段的方法，但是我刚才尝试了下，这种方法会占用内存，例如用#注释的话，解释器会忽略掉#的内容，但是用引号注释的话，python会把他当做一个字符串数值，无论是否有赋值给变量，而内存占用量就是这多出的字符串。
之后的定义函数会说到，在定义函数的第一行使用字符串的话，该字符串会被解释为这个函数的文档！

数学运算

+ 加
- 减
* 乘
/ 除 结果必为浮点数，其他结果在于结果数是否有小数部分、参与数是否是浮点数有关
// 整除 向下取整 -1.1//1 # -2.0
% 取余 取模 结果符号随被除数，钟表取法
** 幂运算
= 赋值

调用未赋值的变量会报错

字符串

'...' "..."
"\"" '\''
"'" '"'
"""..."""
'''...'''
"...\
..."

In [5]:  a=input()^M
   ...: print(a.__str__(),a.__repr__())
jdkajskdjs`     sadjk
jdkajskdjs`     sadjk 'jdkajskdjs`\tsadjk'
In [8]: a.__repr__()
Out[8]: "'213\\tads'"

+ 字符串连接运算，* 字符串重复运算，相邻的两个字符串会自动拼接

"ab"+"3" # 'ab3'
"ab"*3 # 'ababab'
"a" "b" # 'ab'
a=("dsalgflk;dkgl;dkfl;gk"
"glv;dsfkhl;g'gkfdsl;hkl;gfdksl;")
a
"dsalgflk;dkgl;dkfl;gkglv;dsfkhl;g'gkfdsl;hkl;gfdksl;"
或者
a="dsalgflk;dkgl;dkfl;gk"\
"glv;dsfkhl;g'gkfdsl;hkl;gfdksl;"
这种相邻即拼接仅能字符串间操作，不能这样对变量操作，字符串和字符串变量可以用+进行操作

索引

a=“012345”
字符串：012345
索引： 012345
负号索引：-6 -5 -4 -3 -2 -1
注意 -0 和 0 是一样的，所以负数索引从 -1 开始。
a[0] 索引 0
a[0:5] 切片 [-5:5] ‘1234’
a[:5] ‘01234’
a[3:] a[3:6] ‘345’ 这样可以显示最后一位，但是a[6] 超范报错
a[::2] a=“012345” a[::2] # ‘024’
a[::-2] ‘531’ 逆序，但是索引号不变
a[5:0:-1] ‘54321’
a[3::-1] ‘3210’

字符串不可变值：immutable：im不能 mut无足轻重的人 able的 mutable 可以被替代的
向不可变值的索引赋值是错误的，例如字符串、元组

字符串方法生成的新的字符串与源字符串在位置上是不一样的，所以不存在原地操作

更多字符串操作见：python - 字符串总结

str.format()的字符串格式化方式比"%s %d"%(s,d)的方式更先进

列表

squares = [1, 4, 9, 16, 25]
和字符串同为序列类型，sequence，支持索引和切片，拼接、重复
切片返回一个新的列表 [1,2,3][-1:] # [3]
支持拼接 [1,2,3]+[4,5,6] # [1, 2, 3, 4, 5, 6]
以上的新值并不会影响源值

列表是个mutable类型
支持索引赋值 a=[1,2,3];a[1]=4 # [1, 4, 3]
a=[1,2,3];a[1]=[4,5,6] # [1, [4, 5, 6], 3]
支持切片赋值 a=[1,2,3];a[1:]=[4,5,6] # [1, 4, 5, 6]
以上新值会替代源值

list1.append(value)：在列表末尾追加新元素
#等同于list1=list1+[value]，但是更加的高效，这是后面的定义函数中说到的一句话，于是我试了下，真的很高效见下面
list1.extend(list2)：在列表末尾追加新列表 等同于拼接操作
#ex- tend：单向扩展，在list结尾扩展添加新的列表
#ex- pand：多向扩展，tabs大小设置
list1.insert(value)：在索引位置前边插入新元素

删除
list1.pop() 默认删除末尾
list1.pop(0) 删除索引位置的元素
#等同于list1[0]=[] 删除一个元素
#list1[1:3]=[] 删除一个切片
list1.clear()
#等同于list1[:]=[] 删除所有内容

list的效率

%%timeit
list1=[]
for i in range(1000):
    list1=list1+[i]
1.44 ms ± 5.07 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%%timeit
list1=[]
for i in range(1000):
    list1.append(i)
74.3 µs ± 1.13 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%%timeit
list1=list(range(1000))
14.3 µs ± 657 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

毕竟方法1，是把list1重新读写了一遍，例如我想在C盘多写点东西，我就把C盘复制到D盘，在复制出来的后面添加上一个内容，于是形成了一个E盘，然后我再把E盘赋值给C盘。
方法2，就是在C盘的末尾加了个东西，看了上面的那一串很NB的话，再一看这么简单的话，是不是觉得这个简单的话反而懵懵的
方法3，我就是想随手试试！

流程控制

while

while 布尔值:
	语句

布尔值可以是True，通常我用于需要循环得出结果的代码。设置一个条件break出来。

但大多是使用< <= == != >= > is in等进行判断，其判断元素是一个变量，随着输入或是运算而变化。

话说这个和while True 语句判断break是差不多的效果。效率没差多少。

if

if bool:""
elif bool:""
else:""

for

for i in iterable:
	语句

遍历iterable时，不要修改该iterable，如果需要其数据，可以创造一个副本。我之前就是对比两个字符集，但当时并没有意识到这个问题，但我却无意识的去制作了这两个字符集的副本，大概是不想污染了源数据。

list1=list_decimal.copy()
list2=list_digit.copy()
list12=[]
[(list12.append(i),list1.remove(i),list2.remove(i)) for i in list_decimal if i in list_digit]

for i in range(5):""

range()是for的绝配，他生成一个从0~4的序列，执行五次循环操作。
range也可以设置切片和顺序，range就相当于无限长度的数字序列，默认从0开始，但可以指定负数，只能是整数

list(range(-3,3)) # [-3, -2, -1, 0, 1, 2]
list(range(3,9))[::-1] # [8, 7, 6, 5, 4, 3]
list(range(9,3,-1)) # [9, 8, 7, 6, 5, 4]
a=[0,1,2,3,4,5,6,7,8,9];a[9:3:-1] # [9, 8, 7, 6, 5, 4]

再次重复，逆序操作，切片的问题，可以当做先逆序，再切片，切片对应序号和逆序之前的一样。这一次演示中，我又迷糊了，于是希望有道词典可以自定义单词复习！额~ 还真有

range() 所返回的对象在许多方面表现得像一个列表，但实际上却并不是。此对象会在你迭代它时基于
所希望的序列返回连续的项，但它没有真正生成列表，这样就能节省空间。
我们称这样对象为iterable，也就是说，适合作为这样的目标对象：函数和结构期望从中获取连续的项直
到所提供的项全部耗尽。我们已经看到 for 语句就是这样一种结构，而接受可迭代对象的函数的一个例
子是 sum():

 sum(range(4)) # 0 + 1 + 2 + 3 # 6

上面是文档中的一段，提到range()是一个iterable，但是内容确实是range()，只要不被list等操作，他就这么点。于是我想到，.__iter__()、.__reversed__()的性质是否是和他一样呢。

a=range(10)
a # range(0, 10)
type(a) <