Python学习笔记

暑假之后就没有再学了，先挂起来再说

笔记主要内容来自：廖雪峰的官方网站，RUNOOB

基本输入输出

name = input()
print(name)

该语句可以完成基本输入输出，所有输出都可以以此完成

end 关键字

关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符，实例如下：

# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 1000:
    print(b, end=',')
    a, b = b, a+b

本质上如下图

n=b
m=a+b
a=n
b=m

python最具特色的就是使用缩进来表示代码块，不需要使用大括号 {}

缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数

print(L[0][0],'\n')

,换+应该是可行的

实现输出换行

运算符

^符号是用不了的

**用于替代^

Python逻辑运算符

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

内置函数

range()

本身需要转换为list才能全部输出

c = list(range(3))
print (c)

sum()

sum() 方法对序列进行求和计算。

print(sum(range(101)))

enumerate()

即枚举enumerate

for index, item in enumerate(sequence):
    process(index, item)

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

出现在Leetcode题库中的第一题

数据类型和变量

大致与C语言相同

Python3 中有六个标准的数据类型：

Number（数字）

String（字符串）

List（列表）

Tuple（元组）

Set（集合）

Dictionary（字典）

Python3 支持 int、float、bool、complex（复数）。

（居然有复数！！！）

在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

使用type(),instance()进行判断数据类型

string、list 和 tuple 都属于 sequence（序列）。

sequence — 一个序列、迭代器或其他支持迭代对象。

list（列表）（中括号）

相当于数组

List（列表） 是 Python 中使用最频繁的数据类型

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）

初始化

l=[]

list是一种有序的集合，可以随时添加和删除其中的元素。

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates

list1 = ['Google', 'Runoob', 1997, 2000]
list2 = [1, 2, 3, 4, 5, 6, 7 ]
 
print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])

list1[0]:  Google
list2[1:5]:  [2, 3, 4, 5]

Python包含以下函数:

Python包含以下方法:

max函数

list1, list2 = ['Google', 'Runoob', 'Taobao'], [456, 700, 200]

print ("list1 最大元素值 : ", max(list1))
print ("list2 最大元素值 : ", max(list2))

max() 方法返回列表元素中的最大值

可以看出列表中元素为字符串的时候，max 函数的比较是根据 id 的大小来判断的

玄学设计

之前做的

你可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：

变量classmates就是一个list。用len()函数可以获得list元素的个数：

>>> len(classmates)
3

也可以把元素插入到指定的位置，比如索引号为1的位置：

>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

要删除list末尾的元素，用pop()方法：

>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

要删除指定位置的元素，用pop(i)方法，其中i是索引位置：

>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

将列表当做堆栈使用

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。例如：

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

tuple（元组）（小括号）

使用的是小括号

组（tuple）与列表类似，不同之处在于元组的元素不能修改

不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：

>>> classmates = ('Michael', 'Bob', 'Tracy')

修改元组

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2  
print (tup3)

删除元组

使用del就行了

元组运算符

与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

直接白给

字符串

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\\表示的字符就是\，可以在Python的交互式命令行用print()打印字符串看看：

Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串

Set（集合）（大括号）

集合（set）是一个无序的不重复元素序列。

列表转集合时顺序不确定！！！真的

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

居然有这个！！！

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}

print(sites)   # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')


# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)


print(a - b)     # a 和 b 的差集

print(a | b)     # a 和 b 的并集

print(a & b)     # a 和 b 的交集

print(a ^ b)     # a 和 b 中不同时存在的元素

s.add( x ) #添加元素

Dictionary（字典）（大括号里冒号）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

d = {key1 : value1, key2 : value2 }

key为键，value为值

一种可变容器模型，且可存储任意类型对象

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

一种无序映射，本质就是枚举？？？

本质是散列表（占用大量资源实现快速查找）

字典添加使用中括号

如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用Python写一个dict如下：

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
print(d['Bob'])
d['Adam'] = 67
print(d['Adam'])

和list比较，dict有以下几个特点：

1. 查找和插入的速度极快，不会随着key的增加而变慢；
2. 需要占用大量的内存，内存浪费多。

dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
del dict['Name'] # 删除键 'Name'
dict.clear()     # 清空字典
del dict         # 删除字典
 
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

String(字符串)

例子:

var1 = 'Hello World!'
var2 = "Python Runoob"

Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python 访问子字符串，可以使用方括号来截取字符串，如下实例：

var1 = 'Hello World!'
var2 = "Python Runoob"
 
print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

这种操作也是可行的

print (len(var1))

Python字符串运算符

下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：

语法

Python3 基础语法

import 与 from…import

在 python 用 import 或者 from…import 来导入相应的模块。

将整个模块(somemodule)导入，格式为： import somemodule

从某个模块中导入某个函数,格式为： from somemodule import somefunction

从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入，格式为： from somemodule import *

import sys print('================Python import mode==========================') print ('命令行参数为:') for i in sys.argv:    print (i) print ('\n python 路径为',sys.path)

注释

"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号 
这是多行注释，用三个双引号
"""

#进行单行注释

‘’‘进行多行注释

条件判断

判断标准是是否缩进

age = 20
if age >= 6:
    print('teenager')
elif age >= 18:
    print('adult')
else:
    print('kid')

if与elif必须在同一条竖直线上

循环

python上可以无限循环！！！！

无限循环在服务器上客户端的实时请求非常有用。

range()函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

>>>for i in range(0, 10, 3) :
    print(i)
 
    
0
3
6
9
>>>

For循环

为什么会有这种循环？？

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

name在起到字符变量的同时，又起到遍历元素的作用

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")

for……in是句式关键

for……else语句

for n in range(2, 10000):
    for x in range(2, n):
        if n % x == 0:
            #print(n, '等于', x, '*', n//x)
            break
    else:
        # 循环中没有找到元素
        print(n, ' 是质数')

实现质数输出

break后，else不会执行（相当于else是while的一部分）

要注意，C语言没有for else,while else循环

while循环

没有do……while循环

while 循环可以使用 else 语句

while <expr>:
    <statement(s)>
else:
    <additional_statement(s)>

range()函数

for i in range(5,9) :
    print(i)

break 和 continue 语句及循环中的 else 子句

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

n = 5
while n > 0:
    n -= 1
    if n==2:
        break
    print(n)
print('循环结束。')

函数使用

函数定义

先定义一个简单的函数

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

参数传递

在 python 中，类型属于对象，变量是没有类型的：

可更改(mutable)与不可更改(immutable)对象

在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。

• **不可变类型：**变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
• **可变类型：**变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

python 函数的参数传递：

• **不可变类型：**类似 C++ 的值传递，如 整数、字符串、元组。如 fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a)）内部修改 a 的值，则是新生成来一个 a。
• **可变类型：**类似 C++ 的引用传递，如 列表，字典。如 fun(la)，则是将 la 真正的传过去，修改后 fun 外部的 la 也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

空函数

使用pass占位

def nop():
    pass

递归函数

def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

一个实现n!的递归函数

计算过程如下

===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

高级特性

这都是些什么奇奇怪怪的东西

迭代器与生成器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next()。

字符串，列表或元组对象都可用于创建迭代器：

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

迭代器对象可以使用常规for语句进行遍历：

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ") #???

stop()与iteration（迭代的英文）暂时没看懂

import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

切片

迭代

递归函数的优点是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

lambda 表达式

https://www.cnblogs.com/evening/archive/2012/03/29/2423554.html

看个例子：　　　　　

1 g = lambda x:x+1

　　看一下执行的结果：　

　　g(1)