Python学习笔记摘要（一）类型 字符串 函数 列表 深浅拷贝

python中的对象和类型

在python中，认为系统中的每一个“东西”都是一个对象，在python中，“对象”有着特殊的意义，python中的对象有：

一个标识

一些属性

零个或多个名称

当python创建对象时，它接收到一个标识号，可以使用id函数，查找它的ID号，python用这个数字将一个对象和其他对象区分开。除了ID号，对象还有一个或者多个名字，名字不是对象ID的一部分，使用名字是为了提高对象的可读性。python使用命名空间（每当创建新变量时，它被放入列表中，并与一个值关联。如果表中已经存在相同的变量名，则更新与它关联的值）来关联名字。最后每个对象有与之相关联的属性。属性本质上是一些关于对象的信息。

aInt = 7

id(aInt)

type(aInt)

bFloat = 2.5

id(bFloat)

type(bFloat)

aInt = bFloat

type(aInt) －－－aInt is now of type float

id(aInt) －－－aInt’s now has the same ID as bFloat

会发现对象的类型与名字无关，相反它只指定与它相关联的对象，aInt = bFloat将这两个名称关联到同一个对象上。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

数字：

整数：不同的前缀代表不同的进制，例如0代表8进制，0x代表16进制

浮点数（加上前缀例如0是没有意义的）：浮点数是一个近似值，不是精确值，对浮点数进行运算所得到的结果也是近似值。整数是精确值，整数运算得到的也是精确值。

集合：set([1,2,3])

由于类型信息不实变量的一部分，在变量名字前面加上类型作为前缀，对于跟踪类型是有用的，例如intVar，myInt

每种类型都有相关联的构造函数，构造函数的名称就是类型名称（int，float，str…）。如果圆括号内没有给出值，则为该类型的默认值（str的默认值是‘ ’），如果构造函数的括号中出现新的值，就将这个值转为指定类型的新对象（原对象本身不受影响，进行转换后返回新的对象）。

任何时候输入“help（对象名）”，Python将提供该对象的帮助信息

＃＃＃两种相等

python中：

＝＝检查两个名称引用的对象是否具有相同的值

is检查两个名字是否引用同一个对象（具有相同的ID，通过id即可获取ID信息）

多重赋值，交换两个变量的值：

aInt，bInt＝bInt，aInt

python中的缩进，因为缩进代表代码的结构。常见的方式是使用4个空格，这与缩进等价。需要注意的是不要混淆制表符和空格，在python中请使用空格。

while与break，continue的结合：使用break是为了跳出while循环体，使用continue是为了跳过while循环体剩下的部门，直接进行下一次循环的判断

－－－－－－－－－－－－－－－－－－－－

常见函数：

raw_input():输入，返回的是一个字符串类型

random模块中的random.randint(0,100)随机数函数，生成0到100的一个随机数

range函数，生成数字序列（集合），range（start，end，stepLength）

例子：

import random
number = random.randint(0,100)
print "the number is:",number
print "Hi Number Guessing game: between 0 and 100"
guessString = raw_input("please guess a number:")
guess = int(guessString)
while 0<=guess<=100:
if guess>number:
print "Guessed too high"
elif guess<number:
print "Guessed too low"
else:
print "Right"
break
guessString = raw_input("please guess a number:")
guess = int(guessString)
else:
print "You quit early,the number was:",number

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

－－－－－－－－－－－字符串－－－－－－－－－－－－－－－－－－－－－－－－－－－－

（1）

字符串类型是python提供的数据集类型之一，数据集类型是由一组python对象构成的单个对象。

一种构造方式是通过字符串构造函数str，另一种方式是通过两个单引号‘’或两个双引号“”

三重引号字符串：如果字符串跨行，行与行之间的回车符也将被保存下来。采用三重引号字符串会将整个段落作为单个字符串进行处理,包含段落中的格式信息。

longStr2 = “when you’re chewing on life’s gristle

Don’t grumble, give a whistle”

print longStr2

上述就将报错，因为“”不具有跨行保存的功能

制表符 \t

回车符 \n

（2）

字符序列

字符串对象定义为字符序列，字符在字符串中的问题称为索引，python用［］表示索引运算符

如果想从末端建立索引，从－1开始计数，例如－1表示字符串最后一个字符，－2表示字符串倒数第二个字符

索引与分片

Str［start，end]:会截取字符串Str的第start个位置到第end－1个位置的元素（左开右闭区间）

helloString[6 :]:表示第六个到末尾

helloString[: 5]:表示起点到第4个

例子：

import string
#split
line = "bob,carol,ted,alice"
first,second,third,fourth = line.split(",")
print first,second,third,fourth
#
pal1 = "madam, I'm Adam"
print "Forward: %s \nBackward: %s" %(pal1,pal1[::-1])
badChars = string.punctuation + string.whitespace
pal1 = pal1.lower()
for char in pal1:
if char in badChars:
pal1=pal1.replace(char,"")
print pal1
if pal1==pal1[::-1]:
print "pal1 is palindrome"
else:
print "pals is not palindrome"
#replace
str = "abbc"
print str.replace("b","z")

（3）字符串的格式化打印

print "%s is %d years old" % ("bill",25)

# you can define how many space you want by using %Xd,X is the number of the spaces
print "%10s is %-10d years old" % ("bill",25)

print "Pi is %8.4f" % (math.pi) #specify both precision and width

（4）迭代器

由于经常要检查索引和字符，因此python提供了enumerate迭代器，实现查找字符对应的索引和字符本身的功能

for index,letter in enumerate(river):
print index,letter

将两个值放在一个元组中：

for value in enumerate(river):
print value

（5）处理字符串

在空格处分割方法的调用：split(” “)

在每一个逗号处分割的方法调用：split(“,”)

默认采用空格进行分割，所依一般都使用不带参数的split方法

记住，字符串是不可改变的，所以不能从字面上删除原始字符串的任何部分，相反，split只产生部分副本。

numberStr = "3,10,1,7,2,12,4,2,2,1,0"
print numberStr[-1]
print len(numberStr)
print numberStr
print numberStr.split(",")[-1]
print len(numberStr.split(","))
print numberStr.split(",")

结果：

0
23
3,10,1,7,2,12,4,2,2,1,0
0
11
['3', '10', '1', '7', '2', '12', '4', '2', '2', '1', '0']

从上面可以观察看出，split方法将一个字符串变为一个序列进行输出，而不再是字符串

回文：

回文串的特点是前向读取和后向读取得到相同的内容

例子：

import string
#split
line = "bob,carol,ted,alice"
first,second,third,fourth = line.split(",")
print first,second,third,fourth
#
pal1 = "madam, I'm Adam"
print "Forward: %s \nBackward: %s" %(pal1,pal1[::-1])
badChars = string.punctuation + string.whitespace
pal1 = pal1.lower()
for char in pal1:
if char in badChars:
pal1=pal1.replace(char,"")
print pal1
if pal1==pal1[::-1]:
print "pal1 is palindrome"
else:
print "pals is not palindrome"
#replace
str = "abbc"
print str.replace("b","z")

numberStr = "3,10,1,7,2,12,4,2,2,1,0"
print numberStr[-1]
print len(numberStr)
print numberStr
print numberStr.split(",")[-1]
print len(numberStr.split(","))
print numberStr.split(",")

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

－－－－－－－－－－－－－－－－－－－函数－－－－－－－－－－－－－－－－－－－－－－－－－－－

函数定义由关键字def开始。Python中函数定义的方式类似于赋值语句。执行def语句，在命名空间中创建新的名字和与名字相关联的新对象（函数对象）。Python中所有东西都是对象，函数也不例外（函数必须在调用前先定义）。如果不为函数提供return语句，在默认情况下，将返回一个特殊的Python值None,它代表没有值，也是一种无限值,可以将一个变量和返回值None关联起来并打印验证（一般格式化输出喜欢用一个函数封装起来）。

例如：

import string
def length(str):
count = 0
for char in str:
count += 1
return count
def letterCount(str):
count = 0
for char in str.lower():#the function lower() doesn't change the object itself
if char in string.lowercase:
count += 1
print str
return count
print length("What is your quest")
print letterCount("What is your quest")

def formattedOutput(nameOne,nameTwo):
print "Hello %10s, my name is %-10s" % (nameOne,nameTwo)
formattedOutput("Lily","Tom")
result = formattedOutput("Lily","Tom")
print "the result of the function without return is : %s" % (result)

open()函数：两个字符串参数，第一个字符串参数是文件的名称，第二个参数是指出对文件进行什么操作（“r”是读操作，“w”是写操作）并创建文件句柄。文件句柄是与文件内容相关联的对象，可以用文件句柄遍历文件内容

strip（str）函数用于删除字符串开头和结尾的指定字符，例如strip(“.,”)则删除开头和结尾的”,”与”.”

例子：

import string
def length(str):
count = 0
for char in str:
count += 1
return count
def letterCount(str):
count = 0
for char in str.lower():#the function lower() doesn't change the object itself
if char in string.lowercase:
count += 1
print str
return count
print length("What is your quest")
print letterCount("What is your quest")

def formattedOutput(nameOne,nameTwo):
print "Hello %10s, my name is %-10s" % (nameOne,nameTwo)
formattedOutput("Lily","Tom")
result = formattedOutput("Lily","Tom")
print "the result of the function without return is : %s" % (result)

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

－－－－－－－－－－－－－－－－－－－－－－列表和元组－－－－－－－－－－－－－－－－－－－－

可以使用构造函数或者方括号［］来构造列表

使用构造函数创建列表需要注意：参数必须是一个集合，参数集合中的每个元素都将添加到列表中

同字符串一样，列表也是序列类型，但是也有不同点，主要在如下两方面：

（1）列表可以包含任意类型的元素，甚至不同类型的元素也可以混在同一列表中

（2）列表是可变类型，意味着在创建列表对象后，还能发生变化

列表类型也拥有只作用于列表类型的方法：

（1）不修改列表的方法：

index（x）：返回列表中与x相等的第一个元素的索引

count（x）：返回列表中x出现的次数

（2）修改列表的方法：

append（x）：在列表的尾部添加元素，列表的长度加1

pop（）：删除列表末尾的元素，并返回此元素

extend（C）：需要一个集合作为参数。将此参数集合中的每个元素添加到列表的末尾，从而扩展列表。

insert（i，x）：在指定位置i插入元素x

remove（x）：删除列表中第一个值为x的元素

sort（）：对序列中的元素进行排序

reverse（）：将列表中的元素反向

例如：

list = [1,2,3,4,5,6]
print sum(list)
list2= [1,2,5,[4,5,6]]
print len(list2)
print max(list2)

aList = [1,12,5,8]
aList.append(18)
aList.append([4,5,6])
aList.extend([20,2])
aList.remove(18)
aList.count(1)
num = aList.pop()
print aList
print "the pop of the aList is: ", num
aList.reverse()
print "the reserve of the aList is: ",aList
aList.sort()
print "the sort of the aList is:",aList

结果：

21
4
[4, 5, 6]
[1, 12, 5, 8, [4, 5, 6], 20]
the pop of the aList is:  2
the reserve of the aList is:  [20, [4, 5, 6], 8, 5, 12, 1]
the sort of the aList is: [1, 5, 8, 12, 20, [4, 5, 6]]
ehllo

序列的方法会直接在对象上进行分割。不同于字符串方法一般具有返回值，由于序列的可变性，方法可以直接对序列进行修改，因此方法并不需要具有返回值

－－－－使用join方法在列表和字符串之间转换－－－

场景：常常需要通过split从字符串中取出一部分，处理片中的元素，然后再把处理结果放回去。对于这种情况，一种有效方式是采用字符串的join方法。

例如调用：”.”.join([“a”,”b”,”c”]),用冒号（：）作为分隔符，连接所有字符，生成字符串”a:b:c”

sorted函数（注意，不是方法），可以对任意集合类型进行排序，会转化为列表再进行排序

sorted函数原理：（1）使用list构造器将字符串转为字符列表（2）对列表排序

若想变回字符串再使用join方法进行合并

str = "hello"
print "".join(sorted(str))
output:ehllo

——————–可变对象及引用—————————

当两个名字引用同一个可变对象时，会发生一些有趣的事情。

list1 = [1,2,3]
list2 = list1
list1.append(27)

对list1做的改变也会影响list2，因为两个名字都引用了同一个列表（可变对象）

如果想复制列表，可以使用字符串复制分片[:]（从头到尾复制）。明确的说，创建副本意味着Python将创建一个新的对象副本，因此这种修改不会影响其他对象，同样，is运算符显示这些名字没有引用同一对象，所以得到的结果是假。

list1 = [1,2,3]
list2 = list1[:]

可变与不可变：

当变量引用不可变对象时，使用该对象的任何操作（连接，替换，去除等）等将创建新对象，而不会改变引用的对象。与此相反，变量引用可变对象时，或者可能创建新的对象，或者改变被引用对象的本身，这取决于进行的是何种操作。例如：

L = [1,2,3]
L = L + [9]

和

L.append(9)

得到的结果都是[1,2,3,9]。然而，前者创建一个新对象，后者却没有。

深拷贝与浅拷贝

Python中对象的赋值都是进行对象引用（内存地址）传递

使用copy.copy()，可以进行对象的浅拷贝，它复制了对象，但对于对象中的元素，依然使用原始的引用.

需要导入copy模块：

import copy
will = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = copy.copy(will)

如果需要复制一个容器对象，以及它里面的所有元素（包含元素的子元素），可以使用copy.deepcopy()进行深拷贝

import copy
will = ["Will", 28, ["Python", "C#", "JavaScript"]]
wilber = copy.deepcopy(will)

对于非容器类型（如数字、字符串、和其他’原子’类型的对象）没有被拷贝一说

－－－－－未完待续