第二篇--python基础

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
# 将用户输入的内容赋值给 name 变量
name = raw_input("请输入用户名：")
 
# 打印输入的内容
print name

#用print加上字符串，就可以向屏幕上输出指定的文字。
>>>print  "hello world"

dir(sys)            # 显示对象的属性
help(sys)           # 交互式帮助
int(obj)            # 转型为整形
str(obj)            # 转为字符串
len(obj)            # 返回对象或序列长度
open(file,mode)     # 打开文件 #mode (r 读,w 写, a追加)
range(0,3)          # 返回一个整形列表
raw_input("str:")   # 等待用户输入
type(obj)           # 返回对象类型
abs(-22)            # 绝对值
random              # 随机数
choice()            # 随机返回给定序列的一个元素
divmod(x,y)         # 函数完成除法运算，返回商和余数。
round(x[,n])        # 函数返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数
strip()             # 是去掉字符串两端多于空格,该句是去除序列中的所有字串两端多余的空格
del                 # 删除列表里面的数据
cmp(x,y)            # 比较两个对象    #根据比较结果返回一个整数，如果x<y，则返回-1；如果x>y，则返回1,如果x==y则返回0
max()               # 字符串中最大的字符
min()               # 字符串中最小的字符
sorted()            # 对序列排序
reversed()          # 对序列倒序
enumerate()         # 返回索引位置和对应的值
sum()               # 总和
list()              # 变成列表可用于迭代
eval(‘3+4‘)         # 将字符串当表达式求值 得到7
exec ‘a=100‘        # 将字符串按python语句执行
exec(a+‘=new‘)      # 将变量a的值作为新的变量
tuple()             # 变成元组可用于迭代   #一旦初始化便不能更改的数据结构,速度比list快
zip(s,t)            　　   # 返回一个合并后的列表  s = [‘11‘,‘22‘]  t = [‘aa‘,‘bb‘]  [(‘11‘, ‘aa‘), (‘22‘, ‘bb‘)]
isinstance(object,int)    　　　　# 测试对象类型 int 
xrange([lower,]stop[,step])            # 函数与range()类似，但xrnage()并不创建列表，而是返回一个xrange对象

list.append(obj)                 # 向列表中添加一个对象obj
list.count(obj)                  # 返回一个对象obj在列表中出现的次数
list.extend(seq)                 # 把序列seq的内容添加到列表中
list.index(obj,i=0,j=len(list))  # 返回list[k] == obj 的k值,并且k的范围在i<=k<j;否则异常
list.insert(index.obj)           # 在索引量为index的位置插入对象obj
list.pop(-1)                     # 删除并返回指定位置的对象,默认是最后一个对象
list.remove(obj)                 # 从列表中删除对象obj
list.reverse()                   # 原地翻转列表
list.sort(func=None,key=None,reverse=False)  # 以指定的方式排序列表中成员,如果func和key参数指定,则按照指定的方式比较各个元素,如果reverse标志被置为True,则列表以反序排列

string.expandtabs(tabsize=8)                      # tab符号转为空格 #默认8个空格
string.endswith(obj,beg=0,end=len(staring))       # 检测字符串是否已obj结束,如果是返回True #如果beg或end指定检测范围是否已obj结束
string.count(str,beg=0,end=len(string))           # 检测str在string里出现次数  f.count(‘\n‘,0,len(f)) 判断文件行数
string.find(str,beg=0,end=len(string))            # 检测str是否包含在string中
string.index(str,beg=0,end=len(string))           # 检测str不在string中,会报异常
string.isalnum()                                  # 如果string至少有一个字符并且所有字符都是字母或数字则返回True
string.isalpha()                                  # 如果string至少有一个字符并且所有字符都是字母则返回True
string.isnumeric()                                # 如果string只包含数字字符,则返回True
string.isspace()                                  # 如果string包含空格则返回True
string.isupper()                                  # 字符串都是大写返回True
string.islower()                                  # 字符串都是小写返回True
string.lower()                                    # 转换字符串中所有大写为小写
string.upper()                                    # 转换字符串中所有小写为大写
string.lstrip()                                   # 去掉string左边的空格
string.rstrip()                                   # 去掉string字符末尾的空格
string.replace(str1,str2,num=string.count(str1))  # 把string中的str1替换成str2,如果num指定,则替换不超过num次
string.startswith(obj,beg=0,end=len(string))      # 检测字符串是否以obj开头
string.zfill(width)                               # 返回字符长度为width的字符,原字符串右对齐,前面填充0
string.isdigit()                                  # 只包含数字返回True
string.split("分隔符")                             # 把string切片成一个列表
":".join(string.split())                          # 以:作为分隔符,将所有元素合并为一个新的字符串

dict.clear()                          # 删除字典中所有元素
dict copy()                           # 返回字典(浅复制)的一个副本
dict.fromkeys(seq,val=None)           # 创建并返回一个新字典,以seq中的元素做该字典的键,val做该字典中所有键对的初始值
dict.get(key,default=None)            # 对字典dict中的键key,返回它对应的值value,如果字典中不存在此键,则返回default值
dict.has_key(key)                     # 如果键在字典中存在,则返回True 用in和not in代替
dicr.items()                          # 返回一个包含字典中键、值对元组的列表
dict.keys()                           # 返回一个包含字典中键的列表
dict.iter()                           # 方法iteritems()、iterkeys()、itervalues()与它们对应的非迭代方法一样,不同的是它们返回一个迭代子,而不是一个列表
dict.pop(key[,default])               # 和方法get()相似.如果字典中key键存在,删除并返回dict[key]
dict.setdefault(key,default=None)     # 和set()相似,但如果字典中不存在key键,由dict[key]=default为它赋值
dict.update(dict2)                    # 将字典dict2的键值对添加到字典dict
dict.values()                         # 返回一个包含字典中所有值得列表
dict([container])     　　　　　　　　  # 创建字典的工厂函数。提供容器类(container),就用其中的条目填充字典
len(mapping)          　　　　　　　　  # 返回映射的长度(键-值对的个数)
hash(obj)             　　　　　　　　  # 返回obj哈希值,判断某个对象是否可做一个字典的键值 

s.update(t)                         # 用t中的元素修改s,s现在包含s或t的成员   s |= t
s.intersection_update(t)            # s中的成员是共用属于s和t的元素          s &= t
s.difference_update(t)              # s中的成员是属于s但不包含在t中的元素    s -= t
s.symmetric_difference_update(t)    # s中的成员更新为那些包含在s或t中,但不是s和t共有的元素  s ^= t
s.add(obj)                          # 在集合s中添加对象obj
s.remove(obj)                       # 从集合s中删除对象obj;如果obj不是集合s中的元素(obj not in s),将引发KeyError错误
s.discard(obj)                      # 如果obj是集合s中的元素,从集合s中删除对象obj
s.pop()                             # 删除集合s中的任意一个对象,并返回它
s.clear()                           # 删除集合s中的所有元素
s.issubset(t)                       # 如果s是t的子集,则返回True   s <= t
s.issuperset(t)                     # 如果t是s的超集,则返回True   s >= t
s.union(t)                          # 合并操作;返回一个新集合,该集合是s和t的并集   s | t
s.intersection(t)                   # 交集操作;返回一个新集合,该集合是s和t的交集   s & t
s.difference(t)                     # 返回一个新集合,改集合是s的成员,但不是t的成员  s - t
s.symmetric_difference(t)           # 返回一个新集合,该集合是s或t的成员,但不是s和t共有的成员   s ^ t
s.copy()                            # 返回一个新集合,它是集合s的浅复制
obj in s                            # 成员测试;obj是s中的元素 返回True
obj not in s                        # 非成员测试:obj不是s中元素 返回True
s == t                              # 等价测试 是否具有相同元素
s != t                              # 不等价测试 
s < t                               # 子集测试;s!=t且s中所有元素都是t的成员
s > t                               # 超集测试;s!=t且t中所有元素都是s的成员

函数    　　　　　　　　　　返回值 ( 描述 )
abs(x)       　　　　返回数字的绝对值，如abs(-10) 返回 10
ceil(x)      　　　　返回数字的上入整数，如math.ceil(4.1) 返回 5
cmp(x, y)    　　　　如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x)       　　　　返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x)      　　　　返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)     　　　　返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)       　　　　如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)     　　　　返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)     返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)     返回给定参数的最小值，参数可以为序列。
modf(x)    　　　　  返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)    　　　　x**y 运算后的值。
round(x [,n])    　 返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x)    　　　　  返回数字x的平方根，数字可以为负数，返回类型为实数，如math.sqrt(4)返回 2+0j

choice(seq)    　　　　　　　　　　　　  从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
randrange ([start,] stop [,step])     从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为1
random()    　　　　　　　　　　　　　　  随机生成下一个实数，它在[0,1)范围内。
seed([x])    　　　　　　　　　　　　　　 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
shuffle(lst)    　　　　　　　　　　　　 将序列的所有元素随机排序
uniform(x, y)    　　　　　　　　　　　　随机生成下一个实数，它在[x,y]范围内。

acos(x)        返回x的反余弦弧度值。
asin(x)        返回x的反正弦弧度值。    
atan(x)        返回x的反正切弧度值。
atan2(y, x)    返回给定的 X 及 Y 坐标值的反正切值。
cos(x)         返回x的弧度的余弦值。
hypot(x, y)    返回欧几里德范数 sqrt(x*x + y*y)。
sin(x)    　　　返回的x弧度的正弦值。
tan(x)    　　  返回x弧度的正切值。
degrees(x)     将弧度转换为角度,如math.degrees(math.tan(1.0)) ,返回30.0
radians(x)     将角度转换为弧度

str = ’0123456789′
print str[0:3]    #截取第一位到第三位的字符
print str[:]      #截取字符串的全部字符
print str[6:]     #截取第七个字符到结尾
print str[:-3]    #截取从头开始到倒数第三个字符之前
print str[2]      #截取第三个字符
print str[-1]     #截取倒数第一个字符
print str[::-1]   #创造一个与原字符串顺序相反的字符串
print str[-3:-1]  #截取倒数第三位与倒数第一位之前的字符
print str[-3:]    #截取倒数第三位到结尾
print str[:-5:-3] #逆序截取


str2 = str1
str1 =‘abc‘
print str1,str2

#连接字符串
str1 = ‘123‘
str2 = ‘456‘
str1 +=str2
print str1

#字符串查找：
index与find查找的区别:如果使用index查找的元素没在字符串中，则报错，find不报错；
str1 = ‘123‘
print str1.index(‘1‘)
print str1.find(‘1‘)

#字符串比较
str1 = ‘123‘
str3 = ‘123‘
str2 = ‘456‘
print cmp(str1,str2)       #字符串不相同输出-1；
print cmp(str1,str3)       #字符串相同输出0；

#字符串长度
str1 = ‘123456‘
print len(str1)

#字符串大小写转换
str1 = ‘aBcD‘
print str1.upper()          #全部转换为大写
print str1.lower()          #全部转换为小写

#分割字符串
str1 = ‘a,B,c,D‘
print str1.split(‘,‘)

#连接字符串
str1 = [‘a‘,‘B‘,‘c‘,‘D‘]
print ‘,‘.join(str1)

>>>list1 = [1,2,3,4]
>>>list2 = [‘a‘,‘b‘,‘c‘]
>>>list3 = [3,3,5,7,8,9,45,34,7,8,45,34,23,78,9]

>>>print dir(list1)            #查看list1列表中的方法：
#输出：‘append‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘

>>>list1.append(‘a‘)           #append方法：在list1列表中追加元素‘a‘；
>>>print list1　　　　　　　　　  #打印列表元素；
[1,2,3,4,‘a‘]


>>>print list1.count(1)　　　　   #打印元素1在list1列表出现的次数；
1

list1.extend(list2)　　　　　　    #将list2中的元素添加到list1列表中；
print list1 　　　　　　　　　　　　 #打印list1中的元素；
[1, 2, 3, 4, ‘a‘, ‘a‘, ‘b‘, ‘c‘]

>>>print list2.index(‘a‘)　　　　　#打印元素‘a‘在list2中的索引；
0
>>>list1.insert(1,‘a‘)           #在list1列表的索引位置1的地方添加元素‘a‘;
>>>print list1　　　　　　　　　　　#打印list1中的元素；
[1,‘a‘,2,3,4]

>>>print list1.pop(1)　　　　　　　#删除并返回指定索引位置的元素，默认（pop()）为列表最后一个元素；
2
>>>print list1
[1,3,4]


>>>list1.remove(3)　　　　　　　　　#删除list1中的元素3；
>>>print list1
[1,2,4]

>>>list1.reverse()　　　　　　　　　#翻转list1中的元素；
>>>print list1
[4,3,2,1]

>>>list3.sort()　　　　　　　　　　　#按指定的方式排列元素；
>>>print list3
[3, 3, 5, 7, 7, 8, 8, 9, 9, 23, 34, 34, 45, 45, 78]

>>>list3.sort(reverse=True)          #reverse=True时，reverse实现降序排序;
>>>print list3
[78, 45, 45, 34, 34, 23, 9, 9, 8, 8, 7, 7, 5, 3, 3]

>>>tuple1 = (1,2,3,4,23,4,5,72,3,4,6)
‘count‘, ‘index‘

>>>print tuple1.count(4)               #打印元素4在tuple1出现的次数；
>>>print tuple1.index(4)               #打印元素4在tuple1的索引（默认从左到右打印第一个）；
>>>print tuple1.index(4,1,7)           #打印元素4在tuple1的索引,从第一个1开始到第7结束；
>>>tup1 = (50,)                        #元组中只包含一个元素时，需要在元素后面添加逗号；
>>>del tuple1                          #元祖的元素不允许修改和删除，可以使用del删除整个元组；

>>>dict1 ={1:‘a‘,2:‘b‘,3:‘c‘,4:‘d‘}
>>>dict2 ={11:‘aa‘,22:‘bb‘,33:‘cc‘,44:‘dd‘}
>>>print dir(dict1)
‘clear‘, ‘copy‘, ‘fromkeys‘, ‘get‘, ‘has_key‘, ‘items‘, ‘iteritems‘, ‘iterkeys‘, ‘itervalues‘, ‘keys‘, ‘pop‘, ‘popitem‘, ‘setdefault‘, ‘update‘, ‘values‘, ‘viewitems‘, ‘viewkeys‘, ‘viewvalues‘

>>>dict1.clear()                           #清空字典
>>>print dict1
{}

>>>dict2 = dict1.copy()                    #拷贝字典
>>>print dict2
{1:‘a‘,2:‘b‘,3:‘c‘,4:‘d‘}

>>>seq = [1,2,3]                           #seq可以是列表，元组等序列；
>>>dict2 = dict1.fromkeys(seq,3)           #创建并返回一个新字典,以seq中的元素做该字典的键,3做该字典中所有键对的初始值;
>>>print dict2
{1: 3, 2: 3, 3: 3}

>>>print dict1.get(2,1)                    #对字典dict1中的键2，返回其对应的值b,如果不存在此键，返回自定义值1；
b

>>>print dict1.has_key(2)                  #如果键2在字典dict1中存在，返回True，反之为False,可以用in和not in代替
True

>>>print dict1.items()                     #返回一个包含字典中键、值对元组的列表
[(1, ‘a‘), (2, ‘b‘), (3, ‘c‘), (4, ‘d‘)]

>>>for k,v in dict1.iteritems():           #迭代输出字典的键值对,python3.x里面已经废除
      print k,v
1 a
2 b
3 c
4 d

>>>for k in dict1.iterkeys():              #迭代输出字典的键
      print k
1
2
3
4

>>>for v in dict1.itervalues():            #迭代输出字典的值
      print v
a
b
c
d

>>>print dict1.keys()                      #以列表的形式返回字典的所有key
[1, 2, 3, 4]

>>>dict1.pop(4,1)                          #与get方法相似，如果字典中key为4存在，删除并返回其对应的值，如果不存在，返回自定义的1；
d
>>>print dict1
{1: ‘a‘, 2: ‘b‘, 3: ‘c‘}

>>>dict1.popitem()                         #随机删除字典中的一对键和值
>>>print dict1
{2: ‘b‘, 3: ‘c‘, 4: ‘d‘}

>>>dict1.setdefault(40,11)                 #如果字典中不存在键40,由dict1[40]=11为它赋值
>>>print dict1
{40: 11, 1: ‘a‘, 2: ‘b‘, 3: ‘c‘, 4: ‘d‘}

>>>dict1.update(dict2)                     #讲字典dict2中的键值对添加到字典dict1中；
>>>print dict1
{1: ‘a‘, 2: ‘b‘, 3: ‘c‘, 4: ‘d‘, 33: ‘cc‘, 11: ‘aa‘, 44: ‘dd‘, 22: ‘bb‘}

>>>print dict1.values()                    #以列表的形式返回字典的所有values
[‘a‘, ‘b‘, ‘c‘, ‘d‘]

>>>for k,v in dict1.viewitems():           #迭代输出字典的键值对,python3.x里面已经废除
      print k,v
1 a
2 b
3 c
4 d

>>>for k in dict1.viewkeys():              #与iterkeys()相似，迭代输出字典的键
      print k
1
2
3
4

>>>for v in dict1.viewvalues():            #与itervalues()相似，迭代输出字典的值
      print v
a
b
c
d

--第一种：
name = "I‘m %s" % ‘allen‘
name = "I‘m %s, age: %d" % (‘monk‘,25)


   
--第二种     {0}   {1}   x.format(‘xxx‘,‘xxx‘)
传入字符串：
name = "I‘m {0},age:{1}"
new_name = name.format(‘monk‘,25)
print new_name

#传入一个列表：
list1 = [‘monk‘,25]
name = "I‘m {0},age:{1}"
new_name = name.format(*list1)
print new_name

#传入一个字典
dic = {‘name‘:‘monk‘,‘age‘:25}
name = "I‘m {0},age:{1}"
new_name = name.format(**list1)
print new_name

#格式化整数和浮点数还可以指定是否补0和整数与小数的位数：
>>> ‘%2d-%02d‘ % (3, 1) 
‘ 3-01‘ 
>>> ‘%.2f‘ % 3.1415926 
‘3.14‘

#对于Unicode字符串，用法完全一样，最好确保替换的字符串也是Unicode字符串：
>>> u‘Hi, %s‘ % u‘Michael‘ 
u‘Hi, Michael‘  

#有时候字符串里面的%是一个普通字符，需要用%%转义来表示一个%:
>>> ‘growth rate: %d %%‘ % 7 ‘growth rate: 7 %‘ 

#语法格式
if <条件判断1>:
    <执行1>
else:
    <执行2>
#或者：
if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>


age = 3
if age >= 18:
    print ‘your age is‘, age
else:
    print ‘your age is‘, age

#或者：
age = 3
if age >= 18:
    print ‘adult‘
elif age >= 6:
    print ‘teenager‘
else:
    print ‘kid‘

#语法格式
for iterating_var in sequence:
   statements(s)

 
for letter in ‘Python‘:     # First Example
   print ‘Current Letter :‘, letter
 
fruits = [‘banana‘, ‘apple‘,  ‘mango‘]
for fruit in fruits:        # Second Example
   print ‘Current fruit :‘, fruit

#语法格式：
while 判断条件：
    执行语句……

count = 0
while (count < 9):
   print ‘The count is:‘, count
   count = count + 1

for num in range(10,20):  
   for i in range(2,num): 
      if num%i == 0:      
         j=num/i          
         print ‘%d equals %d * %d‘ % (num,i,j)
         break 
   else:                  
      print num, ‘is a prime number‘