字符串对象python基础入门

ahua671

　　PS:今天上午，非常郁闷，有很多简单基础的问题搞得我有些迷茫，哎，代码几天不写就忘。目前又不当COO，还是得用心记代码哦！

一、变量和表达式

>>> 1 + 1               
2
>>> print 'hello world'
hello world
>>> x = 1               
>>> y = 2
>>> x + y
3

　　Python是强类型语言，没法根据上下文主动剖析转换成适合的类型。 Python是一种动态语言，在程序运行中程过，同一个变量名在运行的不同阶段可以代表不同情势的值（整型，浮点，列表，元组），变量名只是各种据数及象的引用。C语言中的变量名是用来寄存结果的存内段片。
　　1、在Python中是通过对象的引用而不是值来赋值给变量的。
　　2、赋值操纵符主要是"="，同时也可应用增量赋值，如 x+=1。但是没有自增、自减操纵符。
　　3、在C语言中，赋值句语可以看成表达式（可以返回值），但是在Python中赋值句语不会返回值，如下面的就是合法的：

>>> x=1
>>> y=(x=x+1)
SyntaxError: invalid syntax

　　以 #! 头开的称为组织行，这行诉告你的Linux/Unix统系当你行执你的程序的时候，它应当运行哪个解释器。例如：#!/usr/bin/python
　　以 # 头开的称为注释行。

二、条件句语
　　控制流句语：通过应用or，and，not关键字可以建立恣意的条件表达式
　　if-elif-else：(Python 没有 switch-case 句语，可以通过 if 句语配合字典实现一样的任务)

if something == 1:   
doSomething1()
elif something == 2:   
doSomething2()
else:   
pass # 示表一个空的块或者是空的主体，应用pass句语
while-else:
while something:   
doSomething1()
else:   
doSomething2()
for-else:
for i in range(1, 10, 2):   # i 值从 1 到 10，步长为2
print i
else:
print 'The for loop is over'

　　break 和 continue：于用断中和继承循环。

三、文件的入输/输出

f=open("foo.txt")
line=f.readline()
while line:
print line,
line=f.readline()  #读取一行，包含换行符'\n'，读到文件尾末，返回空字符串
f.close()
f=open("out.txt","w")
year=1
money=1000
while year<=5:
money=money*(1+0.05)
f.write("%3d %0.2f\n" % (year,money)) # print>>f,"%3d %0.2f" % (year,money)
year+=1
f.close()
for line in f.xreadlines():
# Do something with line


四、内建类型

4.1 None类型
　　None示表空对象。如果一个函数没有示显的返回一个值，None就被返回。None的bool值为false

4.2 数值类型
　　Python有4种数值类型：整数、长整数、浮点数和单数。全部数值类型都是不可变类型。
　　python不持支自增自减操纵符++，--，++i，实际上是+(+i)的意思
　　运算符与表达式：基本上与其它语言相似类，只是有以下几点不同：
　　x*y：乘法。2 * 3到得6。'la' * 3到得'lalala'。
x**y：幂运算，返回 x 的 y 次幂。
x/y：x 除以 y，4/3到得1（整数的除法到得整数结果）。4.0/3或4/3.0到得1.3333333333333333。
x//y：取整除。返回商的整数分部。4 // 3.0到得1.0。
除法//：地板除在任何时候都会将数小分部舍为0
-x  转变x的号符位

4.3 字符串
　　字符串：单引号（‘）和双引号（"）的作用雷同，只能创立单行字符串。转义符是（\）。
　　三引号（如：'''或者"""）之间的一切都是字符串的内容。
　　然自字符串：在字符串前加R（或r）指示某些不须要如转义符那样的别特理处的字符串，如：print R“Hello\n World”，将直接输出“Hello\n World”而不会现出换行的情况。

a="hello world"
b=a[0,5]            # b="hello"
c=a+" I love you"   # c="hello world I love you"
s="The value of x is "+ str(x)

　　得获子串： s[i:j]，返回 s 从i到j（不包含j）之间的子串。若i略省则i=0，若j略省则j=len(s)-1
　　str() repr() 函数或者向后的引号(`)可以将其他类型的据数转换为字符串。
　　Unicode字符串：在字符串前加U（或u）。如 a=u'hello'，个每字符用16位来示表 "hello" 'world'会被主动连接为一个字符串"helloworld" ，"s1" u"s2"就会生发u"s1s2"
　　字符串、Unicode字符串及tuple是不可变的序列。

4.4 列表和元组(list & tuple)
　　列表和元组是恣意对象的序列，持支的用常操纵：
　　len()
append()
insert(index,aMember)
list[index]=aNewMember
　　一个元素的元组：a=(12,)  #注意一定要个外额的逗号！
对于tuple中的元素，不可以修改，也不可以加添
列表是可变的序列，许允插入，除删，替换元素等操纵
　　可变序列持支的操纵：
s=v
s[i:j]=t    # t要是个序列
del s
del s[i:j]

4.5 字典
　　字典就是一个联关组数（或称为哈希表），是一个通过关键字引索的对象合集。
　　应用{}来创立一个字典

a={
"username":"loo"
"home":"/home/loo"
"uid":500
}
u=a["username"]            #拜访
a["username"]="lu"         #修改
a["shell"]="/usr/bin/tcsh" #加添
del a["shell"]             #除删
len(a)                     #元素个数
a[("loo",123)]="abc"

　　字典的key是不能修改的对象（比如数字和tuple）。

五、循环

for i in range(1,5):
print "2 to the %d power is %d" % (i,2**i)

　　内建函数range([i,]j[,stride])建立一个列表，数参i和数参stride是可选的，认默分别为0和1。

a=range(5,1,-1)   # a=[5,4,3,2]


s="hello world"
for c in s:       # 打印个每字符   
print c

　　range()函数在存内中建立一个列表，当须要一个很大的列表时候，这个占存内且耗时间，为了服克这个缺陷，python供给了xrange()。xrange()函数只在须要的时候才临时算计供给值，大大节省了存内。

六、函数

def say(message, times = 1):  # time 的认默数参值是 1
print message * times   
return time               # 无返回值的函数可掉省 return，等同于return None


    每日一道理
如果你们是蓝天，我愿做衬托的白云；如果你们是鲜花，我愿做陪伴的小草；如果你们是大树，我愿做点缀的绿叶……我真诚地希望我能成为你生活中一个欢乐的音符，为你的每一分钟带去祝福。
　　只有在参形表尾末的那些数参可以有认默数参值，即你不能在明声函数参形的时候，先明声有认默值的参形而后明声没有认默值的参形。这是因为赋给参形的值是根据位置而赋值的。例如，def func(a, b=5)是有效的，
　　但是def func(a=5, b)是效无的。
　　global a  # 得获全局变量a
　　用户自定义函数：

def foo(x,y):
print '%s+%s is %s' % (str(x),str(y),str(x+y))
bar=foo
bar(3,4)
d={}
d['callback']=foo
d['callback'](3,4)     # 调用foo

　　用户自定义函数有如下属性：
　　f.__module__                        #函数在所的块模名
f.__doc__ 或者 f.func_doc       #档文字符串
f.__name__ 或者 f.func_name #函数名
f.__dict__ 或者 f.func_dict      #持支恣意函数属性的函数名字空间
f.func_code                          #编译后生发的字节码
f.func_defaults                     #含包全部认默数参的元组
f.func_globals                      #函数在所的块模的全局称名空间的字典
f.func_closure                     #None or a tuple of cells that contain bindings for the function's free variables.

七、类

class Stack(object):
def __init__(self):
self.stack=[]
def push(self,object):
self.stack.append(object)
def pop(self):
return self.stack.pop()
def length(self):
return len(self.stack)
s=Stack()
s.push("Dave")
s.push(42)
s.push([3,4,5])
print s.length()
print s.pop()
y=s.pop()
print y
del s

　　类方法的定义：

# 静态方法：
class AClass(object):
@staticmethod
def astatic():
print 'a static method'
# 类方法：
class ABase(object):
@classmethod
def aclassmethod(cls):
print 'a class method for',cls.__name__

　　isinstance(s,C) 于用试测s否是是C或是C的子类的例实
issubclass(A,B) 于用试测A否是是B的子类

八、异常
　　用try和except句语来捕获异常：

try:
f=open("file.txt","r")
except IOError,e:
print e
except TypeError,e:
print e
...
try:
do something
except:
print 'An error occurred'

　　如果有IOError异常，就将错误因原放置在对象e中，然后运行except代码块，如果生发其他类型的异常就将控制权转到理处该异常的except的代码块，如果没找到该代码块，程序将终止运行，若没有生发异常，except代
　　码会被略忽掉。

九、块模
　　import 块模名
import 块模名 as 别名
from 块模 import 对象(函数)
from 块模 import *
内建函数dir()可以列出一个块模中的全部可拜访的内容
可以被import导入的块模：
1.应用python写的程序（.py程序）
2.C或C++扩展（已编译的同享库或DLL）
3.包（含包多个块模）
4.内建块模（应用C写的并已链接到python解释器内）

十、引用与本副（引用数计）
　　python中的一切据数都是对象。
对于可变对象，转变一个引用就即是转变了该对象的全部的引用：

a=[1,2,3,4]
b=a
b[2]=100
print a   # a=[1,2,100,4]

　　为了防止这类情况，你须要创立一个可变对象的本副，然后对该本副行进操纵。
　　两种创立可变对象的本副：
　　(1)浅拷贝(shallow copy)：创立一个新对象，但它含包的子元素仍然是来原对象子元素的引用：

b=[1,2,[3,4]]
a=b[:]
a.append(100)
print b       # b=[1,2,[3,4]] b没有变
a[0]=100
print b       # b=[1,2,[3,4]] b没有变
a[2][0]=100
print b       # b=[1,2,[100,4]] b被转变了

　　(2)深拷贝(deep copy)

import copy
b=[1,2,[3,4]]
a=copy.deepcopy(b)

　　__del__()在对象销毁时调用。 del x 只是少减对象x的引用数计，不并调用这个函数。

十一、类型转换
　　int(x[,base])   #转换为int
long(x[,base])
float(x)
tuple(x)
list(x)
chr(x)        #转换为字符
unichr(x)     #转换为Unicode字符
ord(x)        #字符转换为整数值  
str(x)
a=[1,2,3,4]
s=repr(a)   # s='[1,2,3,4]'  也可以应用 s='a'
b=eval(s)   # b=[1,2,3,4]    再转换成一个列表
eval('3+4')
f=open("foo")
a=repr(f)  # a="<open file 'foo',mode 'r' at dc030>"

十二、其他
　　档文字符串DocStrings： 如果一个块模、类、函数体的第一个句语是未命名的字符串，改字符串就主动成为该对象的档文字符串 说白了就是似类于JavaDoc的货色。
　　档文字符串的通例是一个多行字符串，它的首行以大写字母开始，句号开头。第二行是空行，从第三行开始是具体的述描。可以应用__doc__（注意双下划线）调用函数的档文字符串属性（属于函数的称名）。Python把每一样货色都作为对象，包含这个函数。
　　Python中的help()，它所做的只是抓取函数的__doc__属性，然后整洁地展示给你。
　　主动化工具也可以以一样的式方从你的程序中取提档文。随Python发行版附带的pydoc令命，与help()似类地应用DocStrings。

def printMax(x, y):
'''Prints the maximum of two numbers.''' # 这里是档文字符串
print "DocStrings"                       # 这里是函数体令命行数参
>>>print printMax.__doc__
Prints the maximum of two numbers.

　　id(a)可以查看该对象的识标（前当的实现是该对象在存内中的位置）

if type(a) is type(b):
print 'a and b have the same type'
if type(a) is types.ListType
print 'Is a list'

　　isinstance(s,C) 于用试测s否是是C或是C的子类的例实

import types
isinstance(3,types.IntType)  #返回True

　　x==y 较比x和y的值否是相称
x is y 和x is not y 较比x和y在存内中否是指向同一个对象
　　推荐文章：
　　Pyhton简史
　　http://www.cnblogs.com/vamei/archive/2013/02/06/2892628.html
　　Python速快教程
　　http://www.cnblogs.com/vamei/archive/2012/09/13/2682778.html
　　Python入门（一）：一句话统计文章不重复汉字数
http://www.cnblogs.com/littlegend/archive/2013/04/12/3016552.html
　　文章结束给大家分享下程序员的一些笑话语录： 雅虎最擅长的不是开通新业务，是关闭旧业务。