python基础篇之一

x = input("input here: ") 输入需要的信息

pow(a, b) -- a**b

round(x) --x四舍五入

abs(x)

//　整数除法运算符

/ 普通除法运算符

import math --将math模块导入

math.floor(32.9) ==> 32

也可以下面这样写：

from math import floor (不推荐使用这种方式，有可能会导致不同的库之间的命名冲突，比如在cmath和math中都有 sqrt，如果使用这种方式就会屏蔽另一

个库中的函数功能；默认情况下建议使用 import math; math.funck()这样的形式使用)

floor(32.9)

python中长字符串换行的时候，可以使用转移字符 \ 或者在字符串定义前使用三个单引号，在输入后，同样输入三个单引号即可。

第二章

序列有两种：列表和元组

列表和元组的区别：列表可以修改元素，而元组不能修改。

因此在如果要使用动态变化的序列时，定义列表比较合适，如果是不能修改的序列时，还是可以使用元组的。事实上，几乎在任何情况下列表都是可以

代替元组的。

列表和元组的的元素之间都是以逗号分割的，序列可以包含序列

ep=[123, "ok"]

mp=[444, "tt"]

all=[ep, mp]

序列的特性：

==================== 列表操作　　===========================================================

1 索引

序列都是以0序号开始的，每个字符串就是一个字符序列；

tt=input("year:")[3] --直接去输入字符串的第四个变量

2 分片（对于索引的是 <= <的关系 "[ )" ）

tt='123456789'

tt[3:6]

进而会有这样的操作 tt[0:3] = tt[:3] 或者逆序取信息 tt[-3:] , tt[:-3]==>注意这里的负索引

对于分片还有一个比较重要的概念叫步长： tt[1:10:2] =〉以步长是2取序列中[1,10)的元素 ==〉步长可以是负元素，即逆序输出

例如tt[9:1:-2]表示以步长是2开始 (2, 9]的形式

3 序列相加

"hello" + "world" => "hello world"

[2,3,4] + "world" ==> failed

python中的乘法

123 *５　

"hello" * 5 ==> hellohellohellohellohello

所以可以使用乘法来初始化一个元组

下面可以写出一个简单的程序来；

sentence = input("input a string here: ");

screen_width=80;

text_width=len(sentence);

box_width = text_width + 6;

left_margin = (screen_width - text_width) // 2;

print (left_margin, screen_width, box_width, text_width, sep = '|');

print(' ' * left_margin + '+' + '-' *(box_width -2 ) + '+');

print(' ' * left_margin + '+' + ' ' *(box_width -2 ) + '+');

print(' ' * left_margin + '+' + sentence + '+');

print(' ' * left_margin + '+' + ' ' *(box_width -2 ) + '+');

print(' ' * left_margin + '+' + '-' *(box_width -2 ) + '+');

加法：

a=[1,3,4]

b=[1,2,3]

c = a+ b ==>将元组按照顺序合并，合并完后不排序

in 的操作：

tt = 'xyz'

x in tt

y in tt

长度和最大值、最小值

tt=[10,20,30]

print(max(tt), min(tt), len(tt), sep = '|')

python中的苦力　list函数，将字符串分为序列

tt="hello"

tt2=list(tt)

tt2 ==> ['h','e','l','l','o']

append方法：

tt=[1,2,3]

tt.append(5)

tt

count():

tt=[[1,2],1,1,[3,4]]

tt.count(1)

tt.count([1,2])

extend():

a=[1,2,3]

b=[4,5,6]

a.extend(b)

a

index()

a=[1,2,3]

a.index(2)

insert():

a = [1,2,3]

a.insert(2,"ok")

a

pop()函数，从栈顶弹出一个元素

a = [1,2,3]

a.pop()

a ==> [1,2]

a.append(a.pop()) ==>pop和append是成对出现的

remove()函数，必须指定要移出的元素的名称　

a=[1,2,3,4,5]

a.remove(2)

a

reverse()：

a=[1,2,3,4,5]

a.reverse()

a

sort():

a=[1,2,5,4,1]

a.sort()

a

======================　元组　　=========================================================

下面是关于元组的一些描述：

元组是不能够修改的一个序列

x=1,2,3 ==> x = (1,2,3)

tuple()函数会把一个列表转化成一个元组

a = list("hello")

b = tuple(a)

b

==================== 字符串操作　　===========================================================

格式化字符串输出：

格式化字符串可以输入到一个变量中，对于后面的值必须是在　%()中的括号中

a = "hello world"

fmtStr="Sting is %s, it's lenght is %d"

print (fmtStr %(a, len(a))); ==> 注意：和Ｃ语言不同的是，格式化字符串和变量之间没有逗号，并且变量都必须放到同一个括号中。

join方法：（只能用户字符串列表，数字列表使用会出错）

a = list("hello world")

sep='|'

sep.join(a) ==> 'h'|'e'|...|'d' ==>这个可以这么理解，分隔符加入到列表中

lower():

a="HELLOW WORLD"

a.lower();

replace():

a="HELLOW WORLD"

a.replace("L", "opo")

a

split()：他是join方法的逆方法

a="1+2+3+4+5"

a.split("+")

a ===> ['1','2','3','4','5']

strip() <==> trim

a = " hello world "

a.strip()

translate()函数功能和ｒｅｐｌａｃｅ相似，但是只能够替换单个字符，在某些情况下效率可能会高些。

==================== 字典操作　　===========================================================

dict={'key':'value1', 'key2':'value2',...}

dict()函数，可以把一个列表影射成一个字典

a=[['key1','key2'],['val1','val2']] // [('key1','key2'),('val1','val2')]

d = dict(a)

d ==> {'key1':'val1', 'key2':'val2'},以后就可以通过　d['key1']

len(d);

d[k] = v

del d[k]

k in d ==>这里使用ｋｅｙ去字典中查找的不是用值查找的。

新建一个字典

x = {}

x[10] = abc

x ==> {10:'abc'}

字典的格式化字符串: %(key)s

tt={'a':20, 'b':30, 'c':40}

fmtStr="dict of a is %(a)s"

print(fmtStr %tt)

clear()清空字典的意思，这里涉及到一个问题，如果把一个字典赋值给另一个字典的话，会出现一个新的副本，如果只是使用｛｝来清空一个字典的话，

不会影响另一个副本，但是如果使用　clear()函数的话会把两个副本都清空

x={}

x[10] ='10'

y=x

x={} 如果　x.clear() ==>y也为空

y ==> {10:'10'}

copy() 和　deepcopy()函数，一个是浅拷贝另一个是深拷贝　==>区别在于，如果是深拷贝的话，一个字典的修改户影响到另一个字典

fromkeys(): 通过列表或者元组元素为ｋｅｙ生成字典，字典的值都为None，

get(): 通过ｋｅｙ来访问ｖａｌｕｅ，即使ｋｅｙ不存在，会返回Ｎｏｎｅ，但是不会报错,而且可以指定默认的返回值

x={}

x.get('name', 'Admin') ==> Admin

has_key() ,判断字典中是否包含key

x={}

x.has_key(10)

items()

a={'a':10,'b':20,'c':30}

a.items() ==> {('a', 10),('b', 20),('c', 30)}

keys() 返回字典中所有的ｋｅｙ

values() 返回字典中所有的值　

pop(key)：返回ｋｅｙ对应的值，并将ｋｅｙ对应的键值对从字典中删除

update() 可以用一个字典来更新另一个字典中的和这个字典ｋｅｙ相同的项

setdefault() 可以给字典中某个项设置默认值，但是如果给这个项赋了值之后，默认值就不起作用了。

d={}

d.setdefault('key1', 'value1')

d['key1'] = value2

d == > {'key1':'value2'}

d.setdefault('key1', 'value1')

d == > {'key1':'value2'}