Skip to main content

01.Python入门笔记

1 什么是python?​

 python是一门动态类型的、面向对象的、解释型的编程语言。动态类型的说明可以写更少的代码，代表开发效率高（指的是相对于静态类型能用更少的代码完成指定的功能，而不是开发者写的快喔）；面向对象可以开发出复杂的应用；解释型使用它可以拿来写个小脚本用解释器就能跑，来完成部分轻量任务。
优点：
开发效率高（写的少，当然快）
缺点：  性能差（指的是在运行脚本等等这些边编译边执行的这些场景）
注: 如果是单例模式且常驻内存运行，从而实现多用户多路复用，则理论性能是可以无限接近静态类型编程的，缺点也很明显，每修改一次就要重启一次来生效修改，随着代码量一多，启动时间也会增长，无数次的调试会让开发员奔溃的，开发效率相对于静态类型也高不到哪去。

2 安装​

2.1 mac 平台​

$ brew install pythone

2.1 其它平台安装​

官方下载地址

3 注意事项​

3.1 代码缩进​

 不同于其它语言，python对缩进是有要求的。如:

>>> if True:
... print(1) # <-- 没有缩进
  File "<stdin>", line 2
    print(1)
    ^
IndentationError: expected an indented block
>>> if True:
...     print(2) # <-- 有缩进
...
2
>>>|

缩进用4个空格；也可以用tab键，来缩进，如果采用tab键而依然报错的话，就是编辑器的tab键不价于4空格，要在编辑器配置下，不会配置就是打4空格吧。

4 变量类型​

4.1 数字​

  数字类型有3种, 整数、浮点数和复数（这个比较特别）。

4.1.1 整数​

 整数精度最大为sys.maxsize(9223372036854775807)

4.1.2 浮点数​

  python 浮点数默认是double精度（又字节64位），采用IEEE754浮点数标准即：
x = （-1） ^s X（1.M）X 2^（E-1023）
e = E - 1023 M尾码是52位，E阶码11位，最大值为： 1.7976931348623157e+308，最小为2.2250738585072014e-308

4.1.3 复数​

  复数是由2部分构成，实数和虚数等。可以看作是实数轴（x）和虚数轴（y）组成的坐标。

>>> foo = 1 + 1j
>>> foo
(1+1j)
>>> type(foo)
<class 'complex'>
>>>|

注：符号j代表虚数部分。我当下还没找到复数的应用场景，可以看成是代数的运算吧： 如：

...
>>> foo + ( 2 - 0.2j )
(3+0.8j)
>>>|
4.1.4 数字类型在运行中的变化​
>>> foo = 1 / 1 <-- 除法返回浮点类型
>>> type(foo)
<class 'float'> 
>>>
>>> foo = 1 // 2 <-- 整除返回整型
>>> foo
0
>>> type(foo)
<class 'int'>
>>>|

4.2 字符串​

4.2.1 声明​

 字符串的声明变量格式可以用'...' 和 "...", 单引号和双引号没什么区别的就是双引号中使用双引号要转义，单引号也一样, 如:

>>> foo = 'string'
>>> print(foo)
string
>>> bar = "string"
>>> print(bar)
string
>>>|
4.2.2 特殊字符处理​

 特殊字符会自动转译, 可以用\或者在引号前加r来禁止转译，如:

>>> print(r'\t1\n2')
\t1\n2
>>> print('\\t1\\n2')
\t1\n2
>>>|
4.2.3 多行输入​

&ems; '''...''' 和 """..."""可以多行格式化声明变量，换行则为\n, 如：

>>> print('''
... 1
... 2
... 3
... ''')
1
2
3

>>>|
4.2.4 逻辑计算​
  • 连接
>>> foo = 'hello ' 'world' # <-- 相邻可进行拼接
>>> print(foo)
hello world
>>> bar = 'hello ' + 'world' # <--- 也可以用 ‘+’ 号来拼接
>>> print(bar)
hello world
>>> |

注： 在由于声明过长，可以多行来声明一个字符变量，使代码简洁

  • 运算
>>> print( 'sutpid ' * 3 + 'where') # <--- * 号可以对单个字符进行重复
sutpid sutpid sutpid where
>>>
4.2.5 切片​
>>> print('12345'[0]) # <--- 访问下标0
1
>>> print('12345'[2:4]) # <--- 访问切片， 既下标2，3
34
>>> print('12345'[:2]) # <--- 即： print('12345'[0:2])
12
>>> print('12345'[2:]) # <--- 即： print('12345'[2:5])
345
>>> print('12345'[-5:-1]) # <--- 开始和结束的下标负数则反向定标取值
1234
>>>|

可以理解为按下标取值,如图:

 +---+---+---+---+---+
 | 1 | 2 | 3 | 4 | 5 |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

4.3 列表类型​

 列表是一组元素的集合，单个元素可以是任意的数据类型: 如

>>> list = [['el1', ['el2.1']], 1, 1/1, 1+1j] # <--- 元素可以是列表、多重列表、整数，浮点数和复数等等
>>> print(list)
[['el1', ['el2.1']], 1, 1.0, (1+1j)]
>>>|
4.3.1 切片​
...
>>> list[0][1]
['el2.1']
>>> list[1:]
[1, 1.0, (1+1j)]
>>> list[:]
[['el1', ['el2.1']], 1, 1.0, (1+1j)]
>>>|
4.3.2 运算​
>>> print([5, 4] + [3, 2, 1]) # <--- 拼接
[5, 4, 3, 2, 1]
>>> list = [1, 2, 3] 
>>> list[2] = 4 # <--- 修改元素
>>> list
[1, 2, 4]
>>> list[0:1] = [] # <--- 清空
>>> list
[2, 4]
>>> list[:] = []
>>> list
[]

5 流程控制​

5.1 判断流程​

5.1.1 while 流程​
>>> a, b = 0, 1
>>> while a < 100: # <--- 条件为真就运行一次
...     print(a, end=',')
...     a, b = b, a + b
...
0,1,1,2,3,5,8,13,21,34,55,89,>>>
5.1.2 if流程​
>>> if  type(foo) == str:
...     print('the type is string')
... elif type(foo) == int:
...     print('the type is int')
... else:
...     print('other types')
...
the type is string
>>>|

5.2 for遍历​

&ems;python的for同C的判断条件跟循环后并计算并迭代不同，python的for只是遍历集合的元素而已。

>>> users = ['foo', 'bar', 'baz']
>>> for user in users:
...     print(user)
...
foo
bar
baz
>>>

5.3 while循环​

>>> n = 0
>>> while n <= 2:
...     print(n, end='\n')
...     n += 1
...
0
1
2
>>>

5.4 break continue和else语句和子句,在遍历和循环中的作用。​

  • continue和break同C一样起到了当前次迭代跳过的作用和中止当前循环代码块的循环终止
  • else配合循环和遍历的使用则起到了当前循环执行完成的类似回调的作用。
for el in range(5):
    print(el)
else:
    print('the for loop success') # <---- 如果for 中没有执行中止 break，则这里就会执行一次。起到了类似遍历次数满足后的回调作用

6 函数​

6. 1 声明​

&ems; 函数的声明心关键字def来标志声明。如：

def foo(name):
    return 'Hi, ', name
print foo('bar') # Hi, bar  <-- called foo function

6.2 传参数说明​

6.2.1 参数的格式​

  参数是可以指定参数名别名传过去的，只要参数别名对的上，则顺序是无所谓的，使用参数名的话，代码的可读性也会更高, 类似于javascript的对象传参。

def tmp(foo, bar, bax = 'bax_default'):
    print('name is foo', foo)
    print('name is bar', bar)
    print('name is bax', bax)

tmp(bax=3, foo=2, bar=1)
# name is foo 2
# name is bar 1
# name is bax 3

当然不用参数名也是可以的, 参数的处理则按顺序来

...
tmp(3, 2, 1)
# name is foo 3
# name is bar 2
# name is bax 1

  总来说，参数的传参格式默认可以按位置顺序来传，类似C有顺序要求, 也可以按参数别名来传，类似javascript对象参数且无位置顺序要求，也可以先按位置再按参数别名来传且按顺序位置来传。
&ems; 也可以指定特定的传参数格式:

def f(pos1, pos2, /, pos_or_kwd, *, kwd1, kwd2):
      ---------- ------------   ------------
        |             |                  |
        |        Positional or keyword   |
        |                                - Keyword only
         -- Positional only
  • 仅限位置则:
def f(arg1, arg2, /):
...
f(1, arg2 = 2) # <--- 位置（顺序）要对
  • 仅限位置则:
def f(*, arg1, arg2):
...
f(arg2 = 2, arg1 = 1) # <--- 关键词要对
6.2.2 列表参数​
def f(arg1, arg2, *other_args):
    print(arg1, arg2)
    print(other_args) # <--- 把更多非关键字的参数以元组的形式传过来
f(1, 2, 3, 4, 5)
# 1 2
# (3, 4, 5)
6.2.3 关键字参数列表​
def f(arg1, arg2, *other_args, **obArgs):
    print(arg1, arg2)
    print(other_args) 
    print(obArgs)  # <--- 把更多关键字的参数以元组的形式传过来
f(1, 2, 3, 4, 5, where = 'where are you?', hello = 'I`m here!')
#  1 2
# (3, 4, 5)
# {'where': 'where are you?', 'hello': 'I`m here!'}

6.3 Lambda表达式​

  可以理解为返回一个闭包, 声明为方式: lambda a, b: a + b;

n = 3
f = lambda x: x + n
print(f(1)) # 4

7 编码风格​

  • 缩进为4空格，尽量不要用tab来缩进
  • 一行长度不超过80个字符
  • 使用空行来分隔函数的和类方法
  • 运算符前后使用空格（靠近括号不算）
  • 类名使用大驼峰命名，函数使用小写蛇形命名
  • 统一使用utf-8编码

8 参考资料​

Python 教程¶
PEP 编码风格指南