python学习笔记

基础

运算符

//表示整除
%求余数
**乘方

语句和表达式
表达式是一些东西，语句是做一些东西
比如

2*2

print(2*2)

floor向上取整

ceil向下取整

用变量来引用函数

foo = math.sqrt
foo(4)=2.0

运行py文件的方法

1.python+_.py(文件路径要给出)

2.或者在py文件头加#!/usr/bin/env python，
然后chmod a+x _py，也要加路径，运行完后，可直接将文件拖入终端即可运行。

字符串

repr将对象转化为解释器能读取的形式

str则是将对象转化为人读取的形式

长字符串```

原始字符串r,结果不会处理中间的/;

但是不能以/结尾，需要对/进行转义，

print(r'c:/book/我是书.txt')
#/结尾出错，需要对/单独转义
raw---print(r'c:/book/this/')
out---print(r'c:/book/this' '//')

unicode,bytes,bytearray

二进制（0，1）表示，每8个一组，为1字节,1字节只能表示256个不同的值，其中bytes只能表示128个值

以后再补

列表和元组

序列--包括

容器：可包含其他对象的对象--主要包括：序列（列表，元组），映射（字典），集合（set）

  • 列表（可修改）
  • 元组（不可修改）

容器container

序列

list
tuple

映射

dict

集合

set

序列操作--索引，切片，相加，相乘。。。

  • 索引从0开始
    字面量可以直接索引，无需变量赋值。

  • 元素切片,第一个索引包括，第二个索引，不包括

即元素个数为前后相减，3:6，即取3个元素，分别为4,5,6

  • 从头开始[ : num];从尾开始[-num : ]

  • [ : ]取整个序列

numbers = [1,2,3,4,5,6,7,8,9,10]
numbers[3:6]
>[4,5,6]
numbers[0:1]
>[0]
numbers[-3:]
>[8,9,10]
  • 步长,隐式，显式
numbers[0:10:2]
>[1, 3, 5, 7, 9]
numbers[::4]
>[1, 5, 9]
numbers[::-2]
>[10, 8, 6, 4, 2]
  • 序列相加，相乘
  • None,空列表[],初始化
  • 判断--布尔值用in来判断
  • 相关函数-len(),max(),min()

list操作

字符串变列表

list('hello')
>['h','e','l','l','o']
' '.join(some_list)
>'book'
  • 修改-索引赋值
  • 删除-del/或者赋值为[]
  • 切片赋值-number[2:] = ['a','b','c','d']

list方法--就是对象的函数

object.method(arguments)调用

1.append-将对象附加到list末尾，对象可以是list或者单一值

2.clear-清空列表内容类似lst[:]=[]，取整个序列赋值为空

3.copy
可以发现，普通操作会同时影响a；需要用到copy方法，

a = [1,2,3,4]
b = a
b[1] = 'k'
>a
[1,'k',3,4]
c = a.copy()
>c[0] = 20
>[20,2,3,4]

4.count-指定元素在list中出现的次数

5.extend-将值附加到list末尾

6.index-指定值第一次出现的索引

7.insert-将一个对象插入列表；插入一个位置，并不会替换掉原值

8.pop-从list中删除一个元素（默认为最后一个）,并返回该元素

栈stack-类似于一叠盘子，上面添加或者上面拿走（后进先出LIFO-last in first out）

a = [1,2,3]
a.pop()
>3
a
>[1,2]

9.remove-删除第一个为指定值的元素；与pop的区别就是不返回值

10.reverse-反转元素（反向排序）,reversed-反向迭代器

11.sort-就地排序，对原list做修改

>x = [2,1,4,9,6]
>y = x.sort()
>print(y)
None
会报错，因为x.sort()是对x进行修改，并不返回值，所以y是None

需要用到copy()方法/或者sorted()函数,返回一个列表；
那么方法和函数的区别是什么呢？function/ method?

12.高级排序

sort()可以接受两个参数，key,reverse。其中将key设置为不同的函数是很有用的。

x.sort(key=len)
x.sort(reverse = True)

元组tuple--也是序列，但不能修改

  • 创建

    • 1.直接输入
    • 2.用()
    • 3.()表示空元组
    • 4.只表示一个值
    >43,
>(43,)

    tuple to list

```
tuple(lst)
```
  • 作用
    • 作为映射中的键
    • 某些内置函数和方法需要返回元组

字符串

设置字符串格式

%

format字符串方法，替换{},每个替换字段用{}。

>"{2}{3},{0} {0} {1}-{3}".format("to","be","or","not")
>'ornot,to to be-not'

字符串方法

1.center-在两端填充字符，使字符串居中
x.center(num,"strings")

2.find-查找子串，找到返回第一个字符的索引，找不到返回-1;可以用来查看是否存在某些元素

>k = "what is the weather today?".center(40,"~")
'~~~~~~~what is the weather today?~~~~~~~'
>k.find('book')
-1
>k.find('is')
12
>k.find('t',12,200)#设置起点和终点，包含起点，不包含终点
15

3.join-用法" ".join(lst),其中元素必须是字符串

4.lower-返回小写字符串，strings.lower();首字母大写strings.title()

5.replace-替换并返回替换后的结果

6.split-与join相反,拆分为序列

7.strip-删除字符串头尾的空白，并返回结果如果strings.strip('*~')删除首尾某些符号

8.translate-同replace,需要一个替换表

9.is开头

字典--映射的数据结构

序列是通过编号来访问值，字典是通过名称来访问

创建字典

键-值

项item：键-值对

{key1:value1,key2:value2....},其中key是唯一的,且不可改变，key可以是字符串，数字，元组

1.dict函数 

>tems = [('name','kobe'),('age',37)]
>d = dict(items)
{'name': 'kobe', 'age': 37}
#或者如下：
>d = dict(name = 'kobe',age=37)

字典方法

1.clear-删除字典所有项，返回None

2.copy-浅复制，替换原件不影响，修改则受影响。这时需要用到copy模块 deepcopy()函数

浅copy和赋值都属于引用对象，深copy则为两个独立对象。

3.fromkeys-创建新字典，包含键，值为None

dict.fromkeys([key1,key2...])

4.get-可以用于访问不存在的key，返回None，或者自设的返回值

d.get(key,strings)-eg.d.get('name','N/A')

5.items-返回list，包含(key,value)

6.keys-返回key的视图

7.pop-删除键-值对

8.popitem-随机删除一项

9.setdefault-类似于get(),没有就往里面加

10.update-更新字典，key相同则替换，不同则往里添加。

条件、循环、其他语句

1.赋值-序列解包(可迭代对象解包)

左右元素必须相等，用*rest可以装剩下的元素,返回list

>x,y,z = 1,2,3
>values = 1,2,3
(1,2,3)
>x,y,z = values

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

赋值语句右边是任何序列，*是一个list

2.链式赋值

x = y = somefun()等价于
x = y和y = somefun()

增强赋值

x + = 1,累计运算

2.条件语句

if _pass_ :

else:
或者
if _pass_:

elif :
else :

比较运算符

  • is-同一个对象,x与z虽然相等，但不是同一个对象；
  • list相等不等于相同，==来检查是否相等，is来看是否属于同一个对象,因为不同的对象可以进过变换成相等的，但本质仍为不同对象。
x = y = [1,2,3]
z = [1,2,3]
>x is y
True
>x == z
True
  • 字符串比较
  • 其实是比较字符的顺序值
  • and,or,not布尔运算符
  • 用assert来判断是否正确

3.迭代

  • 并行迭代
>names = ['a','b','c','d','e']
>ages = [1,2,3,4,5]
>zip(names,ages)#可迭代对象
>list(zip(names,ages))
[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]

  • 迭代获得索引
    enumerate()-可迭代对象，索引-值的元组对

  • 向后迭代和排序后迭代--大小写敏感

sorted()返回一个升序排序后的list

reversed()返回一个逆向排序的迭代器

  • 跳出循环

    • break-满足条件跳出循环
    • continue-
    • while True-
    • 循环中的else语句

  • 推导
    列表表达式

匹配男女同首字母对人

>girls = ['alice','bernice','clarice']

>boys = ['chris','arnold','bob']

lg = {}
for g in girls:
    #g-girl_name;g[0]-first_letter,创建首字母字典，key-letter,value-[],返回一个空list，对其进行append方法
    lg.setdefault(g[0],[]).append(g)
print([B+'+'+G for B in boys for G in lg[B[0]] ])

#字典推导
>{i:"{} squared is {}".format(i,i**2) for i in range(10)}
{0: '0 squared is 0',
 1: '1 squared is 1',
 2: '2 squared is 4',
 3: '3 squared is 9',
 4: '4 squared is 16',
 5: '5 squared is 25',
 6: '6 squared is 36',
 7: '7 squared is 49',
 8: '8 squared is 64',
 9: '9 squared is 81'}

(),{}分别是生成器和字典推导

4.pass,del,exec

  • pass-什么都不做
  • del
  • exce-将字符串作为代码执行,不返回任何值
>exec("print('hello world!')")
hello world!

>eval("input('enter your name: ')")
'tony'
  • eval-返回,计算用字符串表示的python表达式的值

抽象

使用的函数命名应该通俗，一看就知道是做什么的。

  • 函数编写文件-定义函数以后在del后加'strings',代表函数的说明,用func.__doc__查看函数说明。
  • 所有函数都有返回值，没给的话默认是None 
def test():
    print('this is printed')
    return
    print('this is not')

>x = test()
this is printed
>print(x)
None

1.参数

行参-函数名后面的变量

实参-调用函数提供的值

def try_to_change(n):
    n = 'mr.gumby'
name = 'mr.entity'
>try_to_change(name)
>name
'mr.entity'

从该例子可以看出，函数内行参：n,而运行的时候其实就是将name传递给n，对变量name本身并没有影响。参数存储在局部作用域。，如果参数是列表等，则需要用到list方法.copy()
lst[:]得到的是副本。<关键点：是传递变量还是另外新的变量>

关键字参数

可以设置关键字参数，或者定义函数时设置成默认值

#也可以给默认值
#def hello_2(name = '',greeting ='')

def hello_2(name,greeting):
    print('{},{}!'.format(name,greeting))
>hello_2(greeting='how are you',name='tony')
tony,how are you!

收集参数

def func(*params):定义参数时，参数前面加*表示将所有值放入一个元组中，*不收集关键字参数
用**可以收集关键字参数，返回字典

def print_params_4(x,y,z=3,*pospar,**keypar):
    print(x,y,z)
    print(pospar)
    print(keypar)
>print_params_4(1,2,3,4,5,6,7,foo= 1,bar = 2)
1 2 3
(4, 5, 6, 7)
{'foo': 1, 'bar': 2}

分配参数

调用函数的时候，func(*params)，将参数值分配给定义的函数，**是分配字典，*分配（序列）元组或者列表。

作用域

变量类似于看不见的字典,这种看不见的字典就是命名空间或者作用域
局部变量和全局变量

  • globals-返回包含全局变量的字典
  • local-包含局部变量的字典
  • 如果参数重名，则globals()['重名参数']
  • 重新关联-在内部重新定义全局变量global+变量名
  • 作用域嵌套/闭包,更好的理解,调用和引用（在内存中存储了地址）。

递归

抽象2

对象：

多态
不同类型的对象执行相同的操作
封装
对外部隐藏对象工作原理的细节
继承

类

异常

raise

try:
    x = int(input('enter the first number: '))
    y = int(input('enter the second number: '))
    print(x/y)
except ZeroDivisionError:
    print("The second number can't be zero!")

用 try/except xxError来捕获异常

特性和迭代器

模块

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • Python学习笔记
    教程总纲：http://www.runoob.com/python/python-tutorial.html 进阶...
    健康哥哥阅读 2,098评论 1赞 3
  • 2017-08-15
    真爱深沉而非浅薄，真心无私而不贪婪。
    JaryYang阅读 152评论 3赞 4
  • 第一次报道
    敢于承认自己平凡，在内心深处消除“苏格拉底魔咒”，才发现，这个世界，风轻云淡。古人诚不我欺，“宠辱不惊，看...
    半夏悠悠阅读 426评论 0赞 1
  • 当我拒绝负能量之后
    大概是一个月上课之前吧，旁边的有位同学在寝室里受了委屈，然后在上课的时候和前排的同学倾述，虽然不大声，但是作为在旁...
    碎沫阅读 585评论 0赞 1
  • Java Stream match操作(五)
    Stream Head的构建（一）Stream 的中间操作（二）Stream的终止操作（三）本篇讲述match操作...
    风骚无俩阅读 4,899评论 0赞 0