thinkpython2_python2 笔记

***************************************

【Python 应用笔记 THINKCORE】

***************************************

AT+CIPSTART="TCP","47.93.59.179",6001

AT+CWJAP="Pcroom","123456789"

zipimport.ZipImportError: can't decompress data; zlib not available

1环境：yum install readline-devel 安装命令解析

baudrate sync fail ... retry...

GET /devices/5835707 HTTP/1.1api-key: xUrvOCDB=iRuS5noq9FsKrvoW=s=Host:api.heclouds.com\r\n\r\n

AT+CIPSTART="TCP","183.230.40.33",80

【Python 环境搭建】

【变量对象分开】

变量名自身也在内存中

数值也在内存中

变量指向内存的数值

内存回收对象引用计数为0

"=" 用于将变量与内存中的某对象绑定。如果事先存在直接进行绑定

否则则由 “=” 创建引用对象、

test =“too”

vo =“too”

In [21]: id(test)

Out[21]: 46695216

In [22]: id(vo)

Out[22]: 46695216

##############################################################

变量命名规则：

变量名没有类型对象才有

变量可以引用任何对象

【数据结构】

[1,2,3,3,4] ['sfdsf','2322','12'] 列表

列表可变对象：可以修改元素修改（地址变）

In [1]: l1 = ["thin","is","thinkcore"]

In [2]: print l1

['thin', 'is', 'thinkcore']

In [3]: l1[2] = "yoot"

In [4]: print l1

['thin', 'is', 'yoot']

(1,3,2,4,5) ('12','23','2323'); 元祖

元祖不可标对象

切片

In [8]: name = 'jeer'

In [9]: name[0]

Out[9]: 'j'

In [10]: name[2:]

Out[10]: 'er'

In [11]: name[0:4:2]

Out[11]: 'je'

映射：字典

d = {'key'：121,'key1'；1221}

d['key']

可变对象元组是不可变序列

len(name) 获取长度。

is 左右引用对象是不是一样 TURE

In [1]: name ="11"

In [2]: boot="11"

In [3]: name is boot

Out[3]: True

In [4]: type(name) is type(boot)

Out[4]: True

控制流：

if botlweew1:

sdfud1

elif fdsafs2:

dsfs

else _suite

try 异常捕获

输入：

rgw_input

input

In [1]: raw_input("plz input a num:")

plz input a num:dsffds

Out[1]: 'dsffds'

In [4]: a = raw_input("put intput a :")

put intput a thin is a data

In [5]: print a

thin is a data

【print】

In [4]: print "sdfds nu1 %d and %f" %(num1,num2)

sdfds nu1 23 and 12.300000

【类型转换】

In [6]: bootx = 1222;

In [7]: bostst =str(bootx)

In [8]: type(bootx)

Out[8]: int

In [9]: type(bostst)

Out[9]: str

In [1]: name ="thinkcore"

In [2]: name.upper()

Out[2]: 'THINKCORE'

【函数定义】

def pritnname(name);

print name;

In [3]: def printnamex(name):

...: print name

...: print "echo ok!";

...:

In [4]: print

print printnamex

In [4]: printnamex(1223)

1223

echo ok!

In [5]: box= 12123132;

In [6]: printnamex(box)

12123132

echo ok!

【检查方法是否可调用】

In [7]: callable(printnamex)

Out[7]: True

代码结构

#/usr/bin/env python 开始行

*fdsafdsfdsfdfdsf* 模块文档

import sys 模块导入

debug = True 变量定义

class FooClass (object):

*Foo Class*

pass

def test():

*dsfdsfdsf*

foo = FllClass()

if defbug

print 'ran test();

if _name_ == '__main__' : 定义了如果是导入就不执行如果是命令行就执行

test() 主程序

如果被模块导入 __name__ 的值就是模块名字

如果模块是直接执行 __name__的值是 ’__main__'

类型转换】

str() repr() format() : 将非字符型数据转换字符

list() 将字符串转为列表

tuple(s) 将字串S 转换为元组

set(s) 将字串S转为集合

dict(d) 创建字典其D 必须是 (k,vlaue)

数字典型：

python 的数字字面：布尔型：整数浮点复数

True False

字符类型：

字符串字面量：单引号双引号三引号

定义unicode ：在字符串前面加 u

strl =u"hello word"

文档字串：模块类或函数的第一条是一个字符的话叫文档字串

In [12]: def printfunction():

....: "thinkcore is my fennrd"

....: print "zhong guo dianxin"

....:

In [13]: printfunction()

zhong guo dianxin

In [14]: printfunction.__doc__ 【对象名称引用到字符串文档字符串】

Out[14]: 'thinkcore is my fennrd'

In [15]:

适用所有序列的操作和方法

s[i]

s[i:j] s[i:j:len] 切片运算

lens() s 中最小值

In [3]: str1 ="1234567890"

In [4]: min(str1)

Out[4]: '0'

In [5]: max(str1)

Out[5]: '9'

index查找字符串

In [1]: str2="www.thinkcore.com"

In [2]: str2.index("core")

Out[2]: 9

In [3]: str2.index("core",4,9)

replace(old,new[]) 替换字符串

In [1]: str1 ="thinkcore.net.com"

In [2]: str1.replace('net','cn')

Out[2]: 'thinkcore.cn.com'

split 划分对象

In [4]: str1.split('.')

Out[4]: ['thinkcore', 'net', 'com']

del 删除

In [7]: print l1

[1, 2, 'thinkcore', 4, 5]

In [8]: del(l1[3])

append 新增

In [7]: print l1

[1, 2, 'thinkcore', 4, 5]

In [8]: del(l1[3])

insert 插入

In [13]: l1.insert(1,'uoot')

In [14]: print l1

[1, 'uoot', 2, 'thinkcore', 5, 99]

pop 弹出元素

In [15]: l1.pop(2)

Out[15]: 2

In [16]: print l1

[1, 'uoot', 'thinkcore', 5, 99]

合并列表返回新列表但是不会修改原来列表

In [1]: l1 =[1,2,3,4,5]

In [2]: l2=[6,7,8,9,10]

In [3]: l1+l2

Out[3]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

In [4]: l1

Out[4]: [1, 2, 3, 4, 5]

In [5]: l2

Out[5]: [6, 7, 8, 9, 10]

字串连接

In [6]: srt1 ="hello"

In [7]: srt2 ="word"

In [8]: srt1 +srt2

Out[8]: 'helloword'

In [9]: srt1

Out[9]: 'hello'

in：成员关系判断字符

In [10]: l1

Out[10]: [1, 2, 3, 4, 5]

In [11]: 2 in l1

Out[11]: True

字典 dict

{}

条件语句

【if】

“==” 测试值

“is” 对象一致

In [13]: if l1==l2:

....: print "yes l1==l2"

....: else :

....: print "no l1!=l2"

....:

yes l1==l2

In [14]: x=2

In [15]: y=4

In [17]: if x==y:

....: print " y ==x "

....: elif x

....: print "x

....: else :

....: print "y > x"

while【循环 while】

In [2]: url = "www.thinkcor.com"

In [3]: while url:

...: print url

...: url =url[1:];

...:

www.thinkcor.co

ww.thinkcor.co

w.thinkcor.co

.thinkcor.co

thinkcor.co

hinkcor.co

inkcor.co

nkcor.co

kcor.co

cor.co

or.co

r.co

.co

切片

In [18]: while x

....: print x, 【打印不想换行在 print 加，】

....: x+=2

....:

0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50 52 54 56 58 60 62 64 66 68 70 72 74 76 78 80 82 84 86 88 90 92 94 96 98

In [29]: url ="wwww.thinkcore.com"

In [30]: while url:

print url

url = url[:-1]

x +=1;

if x >7:

break

....:

wwww.thinkcore.com

wwww.thinkcore.co

wwww.thinkcore.c

wwww.thinkcore.

wwww.thinkcore

wwww.thinkcor

wwww.thinkco

wwww.thinkc

【for】

for experssion1 in iterable:

for suite

else

else suite

In [3]: for x in url:

print x,

...:

w w w . t h i n k c o r e . c o m 序列迭代：---

In [15]: for i in range(1,101):

....: sum +=i;

....:

In [16]: print sum

xrange(1,100) 比 range() 节约内存

指定索引：*********

for i in range(1,len(11),2)

print l1[i]

迭代【重复做一件事】

iterable (可迭代)对象

支持每次返回自己所包含的一个成员对象

对象实现了__iter__ 方法

In [6]: l1.__iter__()

Out[6]:

In [7]: l1.__iter__()

Out[7]:

In [8]: l1.__iter__()

Out[8]:

In [9]: l1.__iter__()

Out[9]:

每次获取迭代对象迭代器

In [1]: l1 =['noe','two','there','fore']

In [2]: il = l1.__iter__()

In [6]: il.next()

Out[6]: 'noe'

In [7]: il.next()

Out[7]: 'two'

In [8]: il.next()

Out[8]: 'there'

In [9]: il.next()

Out[9]: 'fore'

实现元素遍历接口

迭代器不可逆。

In [10]: i2 = iter(l1)

In [11]: i2.next()

Out[11]: 'noe'

In [12]: i2.next()

Out[12]: 'two'

可跌代对象 list str tuple 非序列 dict file

for 循环开始时，会通过迭代协议传递给iter() 内置函数从而能

够从可迭代对象中获取得到一个迭代器，返回对象含有需要的next 方法。

In [1]: l1=[1,2,3,4,5,6]

In [2]: l2=[]

In [4]: for i in l1:

...: l2.append(i**2)

...:

In [5]: print l2

[1, 4, 9, 16, 25, 36]

In [6]:

【基于已有列表生成新列表方式列表解析】

In [7]: l3 = [i**2 for i in l1 ] 【先写循环体在写表达式】

In [8]: print l3

[1, 4, 9, 16, 25, 36]

先写循环体在写表达式

条件解析

In [10]: l4 = [i**2 for i in l1 if i>=3 ]

In [11]: print l4

[9, 16, 25, 36]

In [17]: for i in [ i**2 for i in range(1,11) ] :print i/2,

0 2 4 8 12 18 24 32 40 50

In [18]:

获取.log 文件结尾方法【s1.endswith('.log')】

In [5]: s1 = 'hello.log'

In [6]: s1.endswith('.log')

Out[6]: True

In [7]: fil3 = [ i for i in files if i.endswith('.log') ]

In [8]: print fil3

['repair.log', 'yum.log', 'ntp.log', 'cloud-init.log', 'boot.log', 'dracut.log', 'agent.log']

In [9]:

二级嵌套

In [9]: l1 = ['x','y','z']

In [10]: l2 = [1,2,3]

In [11]: l3 = [ (i,j) for i in l1 for j in l2 ]

In [12]: print l3

[('x', 1), ('x', 2), ('x', 3), ('y', 1), ('y', 2), ('y', 3), ('z', 1), ('z', 2), ('z', 3)]

In [13]:

In [13]: l3 =[ (i,j) for i in l1 for j in l2 if j !=1 ]

In [14]: print l3

[('x', 2), ('x', 3), ('y', 2), ('y', 3), ('z', 2), ('z', 3)]

生成器表达式节约内存

In [17]: (i**2 for i in range(1,22) )

Out[17]: at 0x1b295f0>

返回一个迭代器

In [18]: lg = (i**2 for i in range(1,22) )

In [20]: lg.next()

Out[20]: 1

In [21]: lg.next()

Out[21]: 4

系列过长并且每次只需要获取一个元素时应当考虑使用生成器而不是列表接解析

【enumerate】

获取元素的索引和元素本身

In [1]: url = 'www.thinkcore.com'

In [2]: enumerate(url)

Out[2]:

In [3]: g1 = en

%env enumerate

In [3]: g1 = enumerate(url)

In [4]: g1.next()

Out[4]: (0, 'w')

In [5]:

In [5]: g1.next()

Out[5]: (1, 'w')

In [6]: g1.next()

Out[6]: (2, 'w')

In [7]: g1.next()

Out[7]: (3, '.')

文件对象【文件对象】

内置函数 open() 打开文件和创建文件对象

open ( name [,mode [,bufsize]])

参数：文件名模式缓冲区

open 函数返回一个文件对象

mode 指定文件打开模式

bufsize 定义输出缓存【 0 无缓存 1 使用缓存(1行) 负数表示系统默认缓存大小】

简单模式：

r: 只读

open('/var/xx.og','r')

w: 写入

a: 附加

在模式使用 “+” 表示同事支持输入输出操作

如 r+ w+ a+

模式后附加b 表示二进制方式打开

如 rb wb+

In [1]: f1 = open('/home/thinkfile/1.txt','r')

In [2]: f1.next()

Out[2]: 'thinkcore dsf tydsfd\n'

In [3]:

In [3]: f1.next()

Out[3]: 'tyesdf fdsfdsf\n'

In [4]: f1.next()

Out[4]: '33333333333\n'

In [5]: f1.next()

Out[5]: '4\n'

fileno() 返回文件描述符

In [6]: f1.fileno()

Out[6]: 4

关于open 模式：

w 以写方式打开

a 以追加模式打开

r+ 以读写模式打开

w+ 以读写模式打开 (参见 w )

a+ 以读写模式打开 (参见 a )

rb 以二进制读模式打开

wb 以二进制写模式打开 (参见 w )

ab 以二进制追加模式打开 (参见 a )

rb+ 以二进制读写模式打开 (参见 r+ )

wb+ 以二进制读写模式打开 (参见 w+ )

ab+ 以二进制读写模式打开 (参见 a+ )

f.write(“str”) #把str写到文件中，write()方法不会在str后加上一个换行符

f.writelines(seq) #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。

f.close() #关闭文件。在读命令或者写命令结束时，需要用关闭。如果文件关闭后依然操作，会抛出ValueError: I/O operation on closed file

f.tell() #返回文件操作标记的当前位置，以文件的开头为起点

fp.next() #返回下一行内容，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。

fp.seek(offset[,whence])#将文件操作标记为移动到offset位置。

每次返回一行

In [17]: f1 = open('/home/thinkfile/1.txt','r')

In [18]: f1.readline()

Out[18]: 'thinkcore dsf tydsfd\n'

In [19]: f1.readline()

Out[19]: 'tyesdf fdsfdsf\n'

In [20]: f1.readline()

Out[20]: '33333333333\n'

In [21]: f1.readline()

Out[21]: '4\n'

返回文件指针在文件的位置

In [26]: f1.tell()

Out[26]: 149

f1.seek (offset [, whence]) 偏移 wence 是开始位置 offset 偏移量

移动指针

whence : 0 从文件头（默认—不定义）

1 从当前位置

2 ：文件尾部

In [3]: f1.seek(1,0)

In [4]: f1.tell()

Out[4]: 1

read(10) 读取10个字节

In [11]: f1.name 【访问当前文件名称】

Out[11]: '/home/thinkfile/1.txt'

In [31]: f2.flush() 【把数据从缓冲区写到文件上】

函数【函数】

In [1]: def f1():

...: x=3

...: def f2():

...: y="hellow"

...: print x,y

...: return f2

...:

In [2]: f1() 得到函数内存

Out[2]:

In [4]: a1 = f1() 赋值给a1 a1 就是一个函数f2()

In [7]: type(a1)

Out[7]: function

In [8]: print a1

In [9]: a1() 调用函数

3 hellow

函数闭合：内层函数调用外层函数而返回时内层函数会记住外层函数的变量

Python 闭包：

变量名引用：本地函数全局内置

def f5(x):

x.pop();

print x

f5(L1[:]); // 传递L1 列表副本修改后不会造成实际L1参数的变化

def F1(*x):

print x

* 定义函数时使用* 开头的参数可以用于任意多基于位置的关键字的参数

2-In [6]: def f2(**x):

...: print x

...:

In [7]: f2(y=2,r=4,t=4)

{'y': 2, 'r': 4, 't': 4}

调用函数时使用的可变参数要求“

定义函数使用 * 收集位置参数

定义函数使用 ** 收集关键字参数

混用：

In [7]: f2(y=2,r=4,t=4)

{'y': 2, 'r': 4, 't': 4}

In [8]: def f1(x, *y):

...: print x ,y

...:

In [9]: f1(1,32,42)

1 (32, 42)

可变参数不能写在左边

In [13]: def f1(*y ,x):

....: print y ,x

....:

File "", line 1

def f1(*y ,x):

SyntaxError: invalid syntax

分解：

In [1]: l1 = ['tink','sunm','nots']

In [2]: x,y,z =l1

In [3]: print x,y,z

tink sunm nots

In [4]:

函数分解

In [4]: def f1(x,c,v):

...: print x,c,v

...:

In [7]: f1(*l1)

tink sunm nots

【lambda args: expression [] 运算符表达式】

lambda x,y: print x,y

thinkpython2_python2 笔记相关推荐

【读书笔记】知易行难，多实践
前言: 其实,我不喜欢看书,只是喜欢找答案,想通过专业的解答来解决我生活的困惑.所以,我听了很多书,也看了很多书,但看完书,没有很多的实践,导致我并不很深入在很多时候. 分享读书笔记: <高效1 ...
【运维学习笔记】生命不息，搞事开始。。。
001生命不息,搞事不止!!! 这段时间和hexesdesu搞了很多事情! 之前是机械硬盘和固态硬盘的测速,我就在那默默的看着他一个硬盘一个机械测来测去. 坐在他后面,每天都能看到这位萌萌的小男孩,各 ...
SSAN 关系抽取论文笔记
20210621 https://zhuanlan.zhihu.com/p/353183322 [KG笔记]八.文档级(Document Level)关系抽取任务共指id嵌入一样但是实体嵌入的时候 ...
pandas以前笔记
# -*- coding: utf-8 -*- """ Created on Sat Jul 21 20:06:20 2018@author: heimi "& ...
PyTorch 学习笔记（六）：PyTorch hook 和关于 PyTorch backward 过程的理解 call
您的位置首页 PyTorch 学习笔记系列 PyTorch 学习笔记(六):PyTorch hook 和关于 PyTorch backward 过程的理解发布: 2017年8月4日 7,195阅读 ...
容器云原生DevOps学习笔记——第三期：从零搭建CI/CD系统标准化交付流程
暑期实习期间,所在的技术中台-效能研发团队规划设计并结合公司开源协同实现符合DevOps理念的研发工具平台,实现研发过程自动化.标准化: 实习期间对DevOps的理解一直懵懵懂懂,最近观看了阿里专家带 ...
容器云原生DevOps学习笔记——第二期：如何快速高质量的应用容器化迁移
暑期实习期间,所在的技术中台-效能研发团队规划设计并结合公司开源协同实现符合DevOps理念的研发工具平台,实现研发过程自动化.标准化: 实习期间对DevOps的理解一直懵懵懂懂,最近观看了阿里专家带 ...
王道考研计算机网络笔记第六章：应用层
本文基于2019 王道考研计算机网络: 2019 王道考研计算机网络个人笔记总结第一章:王道考研计算机网络笔记第一章:概述&计算机网络体系结构第二章:王道考研计算机网络笔记第 ...
王道考研计算机网络笔记第五章：传输层
本文基于2019 王道考研计算机网络: 2019 王道考研计算机网络个人笔记总结第一章:王道考研计算机网络笔记第一章:概述&计算机网络体系结构第二章:王道考研计算机网络笔记第 ...

thinkpython2_python2 笔记

thinkpython2_python2 笔记相关推荐

最新文章

热门文章