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'}