python13_day2

本节内容

本节内容

  1. 列表、元组操作。
  2. 常用的数据类型。
  3. while循环。
  4. 字符串操作
  5. 字典操作
  6. 文件操作
  7. 字符编码与转码

一,列表操作

示例列表:


1

names = [‘Alex‘,"Tenglan",‘Eric‘]

1,下标取值

  • 下标从0开始,第n个值的下标是n-1。
  • 可以倒着取值,比如:name[-1]

1

2

3

4

5

6

7

8

>>> names[0]

‘Alex‘

>>> names[2]

‘Eric‘

>>> names[-1]

‘Eric‘

>>> names[-2] #还可以倒着取

‘Tenglan‘

2,切片

  • 下标切片,取头舍尾。比如name[1:8],只会取下标是1-7的值。
  • 如果从头开始可以不用写下标: name[:6]
  • 如果想要取到最后一个可以:name[2:]
  • 还可以隔几个取值:name[2:2:]

    表示:每隔2个值取一个值,下标从2开始到结束


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

>>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]

>>> names[1:4#取下标1至下标4之间的数字,包括1,不包括4

[‘Tenglan‘, ‘Eric‘, ‘Rain‘]

>>> names[1:-1] #取下标1至-1的值,不包括-1

[‘Tenglan‘, ‘Eric‘, ‘Rain‘, ‘Tom‘]

>>> names[0:3]

[‘Alex‘, ‘Tenglan‘, ‘Eric‘]

>>> names[:3] #如果是从头开始取,0可以忽略,跟上句效果一样

[‘Alex‘, ‘Tenglan‘, ‘Eric‘]

>>> names[3:] #如果想取最后一个,必须不能写-1,只能这么写

[‘Rain‘, ‘Tom‘, ‘Amy‘]

>>> names[3:-1] #这样-1就不会被包含了

[‘Rain‘, ‘Tom‘]

>>> names[0::2] #后面的2是代表,每隔一个元素,就取一个

[‘Alex‘, ‘Eric‘, ‘Tom‘]

>>> names[::2] #和上句效果一样

[‘Alex‘, ‘Eric‘, ‘Tom‘]

3,追加

方法:name.append(“值”

自动会在列表最后追加


1

2

3

4

5

>>> names

[‘Alex‘, ‘Tenglan‘, ‘Eric‘, ‘Rain‘, ‘Tom‘, ‘Amy‘]

>>> names.append("我是新来的")

>>> names

[‘Alex‘, ‘Tenglan‘, ‘Eric‘, ‘Rain‘, ‘Tom‘, ‘Amy‘, ‘我是新来的‘]

4,插入

方法:name.insert(2,"alex")

代表在name中下标为2的值后面插入一个值为alex的元素


1

2

3

4

5

6

7

8

9

>>> names

[‘Alex‘, ‘Tenglan‘, ‘Eric‘, ‘Rain‘, ‘Tom‘, ‘Amy‘, ‘我是新来的‘]

>>> names.insert(2,"强行从Eric前面插入")

>>> names

[‘Alex‘, ‘Tenglan‘, ‘强行从Eric前面插入‘, ‘Eric‘, ‘Rain‘, ‘Tom‘, ‘Amy‘, ‘我是新来的‘]

>>> names.insert(5,"从eric后面插入试试新姿势")

>>> names

[‘Alex‘, ‘Tenglan‘, ‘强行从Eric前面插入‘, ‘Eric‘, ‘Rain‘, ‘从eric后面插入试试新姿势‘, ‘Tom‘, ‘Amy‘, ‘我是新来的‘]

5,修改

方法:name[2] ="alex“

直接去赋值


1

2

3

4

5

>>> names

[‘Alex‘, ‘Tenglan‘, ‘强行从Eric前面插入‘, ‘Eric‘, ‘Rain‘, ‘从eric后面插入试试新姿势‘, ‘Tom‘, ‘Amy‘, ‘我是新来的‘]

>>> names[2] = "该换人了"

>>> names

[‘Alex‘, ‘Tenglan‘, ‘该换人了‘, ‘Eric‘, ‘Rain‘, ‘从eric后面插入试试新姿势‘, ‘Tom‘, ‘Amy‘, ‘我是新来的‘]

6,删除

方法:name.remove["alex"]  删除指定的元素

           name.pop()               删除最后的元素

           del  name[2]      删除指定下标的元素


1

2

3

4

5

6

7

8

9

10

11

12

13

14

>>> del names[2]

>>> names

[‘Alex‘, ‘Tenglan‘, ‘Eric‘, ‘Rain‘, ‘从eric后面插入试试新姿势‘, ‘Tom‘, ‘Amy‘, ‘我是新来的‘]

>>> del names[4]

>>> names

[‘Alex‘, ‘Tenglan‘, ‘Eric‘, ‘Rain‘, ‘Tom‘, ‘Amy‘, ‘我是新来的‘]

>>>

>>> names.remove("Eric") #删除指定元素

>>> names

[‘Alex‘, ‘Tenglan‘, ‘Rain‘, ‘Tom‘, ‘Amy‘, ‘我是新来的‘]

>>> names.pop() #删除列表最后一个值

‘我是新来的‘

>>> names

[‘Alex‘, ‘Tenglan‘, ‘Rain‘, ‘Tom‘, ‘Amy‘]

7,扩展

方法: name.extend(b)

扩展列表name,将列表b加入到列表name中。


1

2

3

4

5

6

>>> names

[‘Alex‘, ‘Tenglan‘, ‘Rain‘, ‘Tom‘, ‘Amy‘]

>>> b = [1,2,3]

>>> names.extend(b)

>>> names

[‘Alex‘, ‘Tenglan‘, ‘Rain‘, ‘Tom‘, ‘Amy‘, 1, 2, 3]

8,拷贝

方法:names=name.copy()

代表将name列表复制一份给names。

当name改变的时候,name是不会变的


1

2

3

4

5

6

>>> names

[‘Alex‘, ‘Tenglan‘, ‘Rain‘, ‘Tom‘, ‘Amy‘, 1, 2, 3]

>>> name_copy = names.copy()

>>> name_copy

[‘Alex‘, ‘Tenglan‘, ‘Rain‘, ‘Tom‘, ‘Amy‘, 1, 2, 3]


1

2

3

4

5

6

7

8

9

10

>>> name

[1, 2, 3, 4, 5, 4, 6]

>>> names=name.copy()

>>> names

[1, 2, 3, 4, 5, 4, 6]

>>> name.append(8)

>>> name

[1, 2, 3, 4, 5, 4, 6, 8]

>>> names

[1, 2, 3, 4, 5, 4, 6] #copy之后,name变了,但是names是不会变的

9,统计

方法:name.count("alex")


1

2

3

4

>>> names

[‘Alex‘, ‘Tenglan‘, ‘Amy‘, ‘Tom‘, ‘Amy‘, 1, 2, 3]

>>> names.count("Amy")

2

10,排序&反转

方法:name.sort()  3.0不同的数据类型不能放在一起排序。

          反转 name.reverse()


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

>>> names

[‘Alex‘, ‘Tenglan‘, ‘Amy‘, ‘Tom‘, ‘Amy‘, 1, 2, 3]

>>> names.sort() #排序

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了,擦

>>> names[-3] = ‘1‘

>>> names[-2] = ‘2‘

>>> names[-1] = ‘3‘

>>> names

[‘Alex‘, ‘Amy‘, ‘Amy‘, ‘Tenglan‘, ‘Tom‘, ‘1‘, ‘2‘, ‘3‘]

>>> names.sort()

>>> names

[‘1‘, ‘2‘, ‘3‘, ‘Alex‘, ‘Amy‘, ‘Amy‘, ‘Tenglan‘, ‘Tom‘]

>>> names.reverse() #反转

>>> names

[‘Tom‘, ‘Tenglan‘, ‘Amy‘, ‘Amy‘, ‘Alex‘, ‘3‘, ‘2‘, ‘1‘]

11,获取下标

方法:name.index["alex"]  #只返回找到的第一个下标

获取alex元素的下标


1

2

3

4

>>> names

[‘Tom‘, ‘Tenglan‘, ‘Amy‘, ‘Amy‘, ‘Alex‘, ‘3‘, ‘2‘, ‘1‘]

>>> names.index("Amy")

2 #只返回找到的第一个下标

二,元组操作

元组

元组其实跟列表差不多,也是存一组数,只不是它一旦创建,便不能再修改,所以又叫只读列表。

         它只有2个方法,一个是count,一个是index,完毕

方法1:name.count("alex")

方法2:name.index("wzb")


1

2

3

4

5

6

7

>>> name=("alex","wzb","liyuan")

>>> name

(‘alex‘, ‘wzb‘, ‘liyuan‘)

>>> name.index("alex")

0

>>> name.count("alex")

1

三、字典操作

字典的特点

1,可以嵌套字典

2,自动去重

3,key:value结构  {‘age‘‘23‘‘job‘‘teacher‘‘addr‘‘beijing‘}

4,如果有多个key只选择一个(自动去重)。

5,小字典直接用 :区分。大字典:{}

6,字典是无序的

字典操作


1

2

3

4

5

6

7

8

9

10

11

12

people = {

    ‘alex‘:{

        ‘age‘:‘23‘,

        ‘addr‘:‘beijing‘,

        ‘job‘:‘teacher‘

    },

    ‘wzb‘:{

        ‘age‘:‘27‘,

        ‘addr‘:‘chengdu‘,

        ‘job‘:‘student‘

    }

}

1,直接取取值

【方法】 dict [key]   


1

2

3

4

5

print(people[‘Alex‘])

{‘phone‘‘3454‘‘addr‘‘beijing‘}

print(people[‘Alex‘])

【方法】 get.dic


1

2

3

4

5

6

7

8

print(people[‘alex‘])

{‘age‘‘23‘‘job‘‘teacher‘‘addr‘‘beijing‘}

print(people[‘ddd‘])

# 报错

print(people.get(‘alex‘))

{‘age‘‘23‘‘job‘‘teacher‘‘addr‘‘beijing‘}

print(people.get(‘dde‘))

None

注:建议使用get.dict(key)不建议使用dict[key],一般情况下不会出错。


2,赋值

【方法】dict[key1][key2]="value"


1

2

3

4

5

people[‘alex‘][‘age‘= ‘25‘

print(people.get(‘alex‘)) #之前是23,打印之后改成25

{‘addr‘‘beijing‘‘job‘‘teacher‘‘age‘‘25‘}

3,添加

【方法】dict[key1][key2]="wanglu"(实际就是赋值的方法,如果这个值没有就自动添加)


1

2

3

people[‘alex‘][‘phone‘]="1356"

print(people)

{‘wzb‘: {‘age‘‘27‘‘addr‘‘chengdu‘‘job‘‘student‘}, ‘alex‘: {‘age‘‘23‘‘addr‘‘beijing‘‘job‘‘teacher‘‘phone‘‘1356‘}}

4,删除

【方法】del dict[key][value]


1

2

3

4

5

del people[‘alex‘][‘age‘#key ‘alex‘ 下的value‘age‘ 被删除了

print(people)

{‘alex‘: {‘addr‘‘beijing‘‘job‘‘teacher‘}, ‘wzb‘: {‘age‘‘27‘‘addr‘‘chengdu‘‘job‘‘student‘}}

【方法】dict[key].pop(value)


1

2

3

4

5

people[‘wzb‘].pop(‘addr‘#删除了wzb中的addr的值

 

print(people)

 

{‘wzb‘: {‘job‘‘student‘‘age‘‘27‘}, ‘alex‘: {‘job‘‘teacher‘‘addr‘‘beijing‘‘age‘‘23‘}}

5,字典更新

【方法】update 

dict1.update(dict2)        # 用dict2更新id_db 如果有就覆盖,如果没有就更新。


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

people2 = {

    ‘zzz‘:{

        ‘age‘:‘23‘,

        ‘addr‘:‘beijing‘,

        ‘job‘:‘teacher‘

    },

    ‘bbb‘:{

        ‘addr‘:‘chengdu‘,

        ‘job‘:‘student‘

    }

}

people.update(people2)#用字典people2去更新字典people

print(people)

{‘bbb‘: {‘addr‘‘chengdu‘‘job‘‘student‘}, ‘wzb‘: {‘addr‘‘chengdu‘‘job‘‘student‘‘age‘‘27‘}, ‘alex‘: {‘addr‘‘beijing‘‘job‘‘teacher‘‘age‘‘23‘}, ‘zzz‘: {‘addr‘‘beijing‘‘job‘‘teacher‘‘age‘‘23‘}}

7,字典变列表

 【方法】dict.items 

#把字典变成列表,如果数据很大不要这样处理非常耗时。不建议使用。


1

2

3

print(people.items())

 

dict_items([(‘wzb‘, {‘job‘‘student‘‘age‘‘27‘‘addr‘‘chengdu‘}), (‘alex‘, {‘job‘‘teacher‘‘age‘‘23‘‘addr‘‘beijing‘})])

8,key和value 值

【方法】dict.values()          dict.keys()


1

2

3

4

5

print(people.values(),people.keys())

dict_values([{‘job‘‘student‘‘age‘‘27‘‘addr‘‘chengdu‘}, {‘job‘‘teacher‘‘age‘‘23‘‘addr‘‘beijing‘}])

dict_keys([‘wzb‘‘alex‘])

9,key in dict 的用法

  【 方法】key   in   dict       #仅限python3中使用


1

2

3

4

5

6

for key in people:

    print(key)

   alex

   wzb

10,setdefault用法

【方法】dict.setdefault(key,”value")

#取一个key,如果不存在,就默认添加一个。如果存在不会改变。


1

2

3

4

5

6

7

people[‘alex‘].setdefault(‘phone‘,‘ddd‘)

#alex的子字典中,找一个phone的值,如没有就添加。

print(people)

{‘wzb‘: {‘addr‘‘chengdu‘‘age‘‘27‘‘job‘‘student‘}, ‘alex‘: {‘addr‘‘beijing‘‘age‘‘23‘‘job‘‘teacher‘‘phone‘‘ddd‘}}


1

2

3

4

5

people.setdefault(‘age‘,‘24‘#本身字典里没有age所以添加了一个age

print(people)

{‘wzb‘: {‘job‘‘student‘‘addr‘‘chengdu‘‘age‘‘27‘}, ‘alex‘: {‘job‘‘teacher‘‘addr‘‘beijing‘‘age‘‘23‘}, ‘age‘‘24‘}

11,dict.fromkeys

【方法】dict.fromkeys(list,value)

#把列表中每一个值拿出来当成新字典的keys。


1

2

3

4

5

people2 = people.fromkeys([‘wz‘,‘wu‘,‘ub‘],‘wwww‘)

print(people2)

{‘wz‘‘wwww‘‘wu‘‘wwww‘‘ub‘‘wwww‘}

12,字典随机删除

【方法】dict.popitem()

#随机删除,一般不用


1

2

3

4

5

6

7

people2 = people.popitem()

 

#随机删除people下的一个子字典

 

print(people2)

 

(‘wzb‘, {‘age‘‘27‘‘addr‘‘chengdu‘‘job‘‘student‘})

13,判断元素在字典中否

方法:key   in dict:


1

if username in user_dict

14,循环一个字典

【方法1】for keys,values in dict.items():

#效率效率低,而且需要把字典转换成list。占用内存

【方法2】 for key in dict: #效率高,而且不用转换类型

                           print(key,dict[key])


1

2

3

4

5

for key in people:

  print(key,people[key])

alex {‘age‘‘23‘‘job‘‘teacher‘‘addr‘‘beijing‘}

wzb {‘age‘‘27‘‘job‘‘student‘‘addr‘‘chengdu‘}


三、字符串操作

1、去空格及特殊符号

复制代码代码如下:

s.strip().lstrip().rstrip(‘,‘)

2、复制字符串

复制代码代码如下:

#strcpy(sStr1,sStr2)
sStr1 = ‘strcpy‘
sStr2 = sStr1
sStr1 = ‘strcpy2‘
print sStr2

3、连接字符串

复制代码代码如下:

#strcat(sStr1,sStr2)
sStr1 = ‘strcat‘
sStr2 = ‘append‘
sStr1 += sStr2
print sStr1

4、查找字符

复制代码代码如下:

#strchr(sStr1,sStr2)
# < 0 为未找到
sStr1 = ‘strchr‘
sStr2 = ‘s‘
nPos = sStr1.index(sStr2)
print nPos

5、比较字符串

复制代码代码如下:

#strcmp(sStr1,sStr2)
sStr1 = ‘strchr‘
sStr2 = ‘strch‘
print cmp(sStr1,sStr2)

6、扫描字符串是否包含指定的字符


复制代码代码如下:

#strspn(sStr1,sStr2)
sStr1 = ‘12345678‘
sStr2 = ‘456‘
#sStr1 and chars both in sStr1 and sStr2
print len(sStr1 and sStr2)

7、字符串长度


复制代码代码如下:

#strlen(sStr1)
sStr1 = ‘strlen‘
print len(sStr1)

8、将字符串中的大小写转换


复制代码代码如下:

S.lower() #小写 
S.upper() #大写 
S.swapcase() #大小写互换 
S.capitalize() #首字母大写 
String.capwords(S) #这是模块中的方法。它把S用split()函数分开,然后用capitalize()把首字母变成大写,最后用join()合并到一起 
#实例:
#strlwr(sStr1)
sStr1 = ‘JCstrlwr‘
sStr1 = sStr1.upper()
#sStr1 = sStr1.lower()
print sStr1

9、追加指定长度的字符串

复制代码代码如下:

#strncat(sStr1,sStr2,n)
sStr1 = ‘12345‘
sStr2 = ‘abcdef‘
n = 3
sStr1 += sStr2[0:n]
print sStr1

10、字符串指定长度比较


复制代码代码如下:

#strncmp(sStr1,sStr2,n)
sStr1 = ‘12345‘
sStr2 = ‘123bc‘
n = 3
print cmp(sStr1[0:n],sStr2[0:n])

11、复制指定长度的字符


复制代码代码如下:

#strncpy(sStr1,sStr2,n)
sStr1 = ‘‘
sStr2 = ‘12345‘
n = 3
sStr1 = sStr2[0:n]
print sStr1

12、将字符串前n个字符替换为指定的字符

复制代码代码如下:

#strnset(sStr1,ch,n)
sStr1 = ‘12345‘
ch = ‘r‘
n = 3
sStr1 = n * ch + sStr1[3:]
print sStr1

13、扫描字符串

复制代码代码如下:

#strpbrk(sStr1,sStr2)
sStr1 = ‘cekjgdklab‘
sStr2 = ‘gka‘
nPos = -1
for c in sStr1:
    if c in sStr2:
        nPos = sStr1.index(c)
        break
print nPos

14、翻转字符串


复制代码代码如下:

#strrev(sStr1)
sStr1 = ‘abcdefg‘
sStr1 = sStr1[::-1]
print sStr1

15、查找字符串

复制代码代码如下:

#strstr(sStr1,sStr2)
sStr1 = ‘abcdefg‘
sStr2 = ‘cde‘
print sStr1.find(sStr2)

16、分割字符串


复制代码代码如下:

#strtok(sStr1,sStr2)
sStr1 = ‘ab,cde,fgh,ijk‘
sStr2 = ‘,‘
sStr1 = sStr1[sStr1.find(sStr2) + 1:]
print sStr1
#或者
s = ‘ab,cde,fgh,ijk‘
print(s.split(‘,‘))

17、连接字符串


复制代码代码如下:

delimiter = ‘,‘
mylist = [‘Brazil‘, ‘Russia‘, ‘India‘, ‘China‘]
print delimiter.join(mylist)

18、PHP 中 addslashes 的实现


复制代码代码如下:

def addslashes(s):
    d = {‘"‘:‘\\"‘, "‘":"\\‘", "\0":"\\\0", "\\":"\\\\"}
    return ‘‘.join(d.get(c, c) for c in s)

s = "John ‘Johny‘ Doe (a.k.a. \"Super Joe\")\\\0"
print s
print addslashes(s)

19、只显示字母与数字

复制代码代码如下:

def OnlyCharNum(s,oth=‘‘):
    s2 = s.lower();
    fomart = ‘abcdefghijklmnopqrstuvwxyz0123456789‘
    for c in s2:
        if not c in fomart:
            s = s.replace(c,‘‘);
    return s;

print(OnlyStr("a000 aa-b"))

20、截取字符串

复制代码代码如下:

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] #逆序截取,具体啥意思没搞明白?

21、字符串在输出时的对齐

复制代码代码如下:

S.ljust(width,[fillchar]) 
#输出width个字符,S左对齐,不足部分用fillchar填充,默认的为空格。 
S.rjust(width,[fillchar]) #右对齐 
S.center(width, [fillchar]) #中间对齐 
S.zfill(width) #把S变成width长,并在右对齐,不足部分用0补足

22、字符串中的搜索和替换 


复制代码代码如下:

S.find(substr, [start, [end]]) 
#返回S中出现substr的第一个字母的标号,如果S中没有substr则返回-1。start和end作用就相当于在S[start:end]中搜索 
S.index(substr, [start, [end]]) 
#与find()相同,只是在S中没有substr时,会返回一个运行时错误 
S.rfind(substr, [start, [end]]) 
#返回S中最后出现的substr的第一个字母的标号,如果S中没有substr则返回-1,也就是说从右边算起的第一次出现的substr的首字母标号 
S.rindex(substr, [start, [end]]) 
S.count(substr, [start, [end]]) #计算substr在S中出现的次数 
S.replace(oldstr, newstr, [count]) 
#把S中的oldstar替换为newstr,count为替换次数。这是替换的通用形式,还有一些函数进行特殊字符的替换 
S.strip([chars]) 
#把S中前后chars中有的字符全部去掉,可以理解为把S前后chars替换为None 
S.lstrip([chars]) 
S.rstrip([chars]) 
S.expandtabs([tabsize]) 
#把S中的tab字符替换没空格,每个tab替换为tabsize个空格,默认是8个

23、字符串的分割和组合 


复制代码代码如下:

S.split([sep, [maxsplit]]) 
#以sep为分隔符,把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符 
S.rsplit([sep, [maxsplit]]) 
S.splitlines([keepends]) 
#把S按照行分割符分为一个list,keepends是一个bool值,如果为真每行后而会保留行分割符。 
S.join(seq) #把seq代表的序列──字符串序列,用S连接起来

24、字符串的mapping,这一功能包含两个函数

复制代码代码如下:

String.maketrans(from, to) 
#返回一个256个字符组成的翻译表,其中from中的字符被一一对应地转换成to,所以from和to必须是等长的。 
S.translate(table[,deletechars]) 
# 使用上面的函数产后的翻译表,把S进行翻译,并把deletechars中有的字符删掉。需要注意的是,如果S为unicode字符串,那么就不支持 deletechars参数,可以使用把某个字符翻译为None的方式实现相同的功能。此外还可以使用codecs模块的功能来创建更加功能强大的翻译表。

25、字符串还有一对编码和解码的函数

复制代码代码如下:

S.encode([encoding,[errors]]) 
# 其中encoding可以有多种值,比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。errors默认值为"strict",意思是UnicodeError。可能的值还有‘ignore‘, ‘replace‘, ‘xmlcharrefreplace‘, ‘backslashreplace‘ 和所有的通过codecs.register_error注册的值。这一部分内容涉及codecs模块,不是特明白 
S.decode([encoding,[errors]])

26、字符串的测试、判断函数,这一类函数在string模块中没有,这些函数返回的都是bool值

复制代码代码如下:

S.startswith(prefix[,start[,end]]) 
#是否以prefix开头 
S.endswith(suffix[,start[,end]]) 
#以suffix结尾 
S.isalnum() 
#是否全是字母和数字,并至少有一个字符 
S.isalpha() #是否全是字母,并至少有一个字符 
S.isdigit() #是否全是数字,并至少有一个字符 
S.isspace() #是否全是空白字符,并至少有一个字符 
S.islower() #S中的字母是否全是小写 
S.isupper() #S中的字母是否便是大写 
S.istitle() #S是否是首字母大写的

27、字符串类型转换函数,这几个函数只在string模块中有

复制代码代码如下:

string.atoi(s[,base]) 
#base默认为10,如果为0,那么s就可以是012或0x23这种形式的字符串,如果是16那么s就只能是0x23或0X12这种形式的字符串 
string.atol(s[,base]) #转成long 
string.atof(s[,base]) #转成float

这里再强调一次,字符串对象是不可改变的,也就是说在python创建一个字符串后,你不能把这个字符中的某一部分改变任何上面的函数改变了字符串后,都会返回一个新的字符串,原字串并没有变。其实这也是有变通的办法的,可以用S=list(S)这个函数把S变为由单个字符为成员的list,这样的话就可以使用S[3]=‘a‘的方式改变值,然后再使用S=" ".join(S)还原成字符串

四、pyc是什么

一、.pyc是个什么鬼?(摘自alex)

1. Python是一门解释型语言?

我初学Python时,听到的关于Python的第一句话就是,Python是一门解释性语言,我就这样一直相信下去,直到发现了*.pyc文件的存在。如果是解释型语言,那么生成的*.pyc文件是什么呢?c应该是compiled的缩写才对啊!

为了防止其他学习Python的人也被这句话误解,那么我们就在文中来澄清下这个问题,并且把一些基础概念给理清。

 

2. 解释型语言和编译型语言

计算机是不能够识别高级语言的,所以当我们运行一个高级语言程序的时候,就需要一个“翻译机”来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分成两类,第一种是编译,第二种是解释。

编译型语言在程序执行之前,先会通过编译器对程序执行一个编译的过程,把程序转变成机器语言。运行时就不需要翻译,而直接执行就可以了。最典型的例子就是C语言。

解释型语言就没有这个编译的过程,而是在程序运行的时候,通过解释器对程序逐行作出解释,然后直接运行,最典型的例子是Ruby。

通过以上的例子,我们可以来总结一下解释型语言和编译型语言的优缺点,因为编译型语言在程序运行之前就已经对程序做出了“翻译”,所以在运行时就少掉了“翻译”的过程,所以效率比较高。但是我们也不能一概而论,一些解释型语言也可以通过解释器的优化来在对程序做出翻译时对整个程序做出优化,从而在效率上超过编译型语言。

此外,随着Java等基于虚拟机的语言的兴起,我们又不能把语言纯粹地分成解释型和编译型这两种。

用Java来举例,Java首先是通过编译器编译成字节码文件,然后在运行时通过解释器给解释成机器文件。所以我们说Java是一种先编译后解释的语言。

3. Python到底是什么

其实Python和Java/C#一样,也是一门基于虚拟机的语言,我们先来从表面上简单地了解一下Python程序的运行过程吧。

当我们在命令行中输入python hello.py时,其实是激活了Python的“解释器”,告诉“解释器”:你要开始工作了。可是在“解释”之前,其实执行的第一项工作和Java一样,是编译。

熟悉Java的同学可以想一下我们在命令行中如何执行一个Java的程序:

javac hello.java

java hello

只是我们在用Eclipse之类的IDE时,将这两部给融合成了一部而已。其实Python也一样,当我们执行python hello.py时,他也一样执行了这么一个过程,所以我们应该这样来描述Python,Python是一门先编译后解释的语言。

4. 简述Python的运行过程

在说这个问题之前,我们先来说两个概念,PyCodeObject和pyc文件。

我们在硬盘上看到的pyc自然不必多说,而其实PyCodeObject则是Python编译器真正编译成的结果。我们先简单知道就可以了,继续向下看。

python程序运行时,编译的结果则是保存在位于内存中的PyCodeObject中,当Python程序运行结束时,Python解释器则将PyCodeObject写回到pyc文件中。

当python程序第二次运行时,首先程序会在硬盘中寻找pyc文件,如果找到,则直接载入,否则就重复上面的过程

所以我们应该这样来定位PyCodeObject和pyc文件,我们说pyc文件其实是PyCodeObject的一种持久化保存方式


五、json使用和os使用

1,os模块的使用


1

2

3

4

5

6

import os

if os.path.exists(‘user.json‘):  # 判断user.json是否存在,存在打印相关信息。

    print("The file is exist.")

else:

    print("Please check your file."# 不存在则退出程序。

    exit()

2,json的使用


1

2

3

4

5

6

7

8

9

10

11

12

13

import json

读取文件

file = ‘user.json‘

fp = open(file, ‘r‘)

user_dict = json.load(fp)  # 打开将json中内容读取到字典user_dict中来,使用完毕关闭文件。

fp.close()

简化之后

user_dict = json.load(open(‘user.json‘,‘r‘))

写入文件

json.dump(user_dict, open(‘user.json‘, ‘w‘))

fp.close()

常用数据类型

一、整数(int)

如: 18、73、84

二、长整型(long int)

可能如:2147483649、9223372036854775807

三、浮点型(float)

如:3.14、2.88

四、字符串(str)

如:‘wupeiqi‘、‘alex‘

五、列表(list)

如:[11,22,33]、[‘wupeiqi‘, ‘alex‘]

六、元组(tuple)

如:(11,22,33)、(‘wupeiqi‘, ‘alex‘)

七、字典(dict)

如:{‘name‘: ‘wupeiqi‘, ‘age‘: 18} 、{‘host‘: ‘2.2.2.2‘, ‘port‘: 80]}

ps:循环时,默认循环key

八、布尔值

  真或假

  1 或 0

常见运算符

算数运算:

比较运算:

赋值运算:

逻辑运算:

成员运算:

身份运算:

位运算:

运算符优先级:

文件操作

python读写文件

1.open

使用open打开文件后一定要记得调用文件对象的close()方法。比如可以用try/finally语句来确保最后能关闭文件。

file_object = open(‘thefile.txt‘)

try:

all_the_text = file_object.read( )

finally:

file_object.close( )

注:不能把open语句放在try块里,因为当打开文件出现异常时,文件对象file_object无法执行close()方法。

2.读文件

读文本文件

input = open(‘data‘, ‘r‘)

#第二个参数默认为r

input = open(‘data‘)

读二进制文件

input = open(‘data‘, ‘rb‘)

读取所有内容

file_object = open(‘thefile.txt‘)

try:

all_the_text = file_object.read( )

finally:

file_object.close( )

读固定字节

file_object = open(‘abinfile‘, ‘rb‘)

try:

while True:

chunk = file_object.read(100)

if not chunk:

break

do_something_with(chunk)

finally:

file_object.close( )

读每行

list_of_all_the_lines = file_object.readlines( )

如果文件是文本文件,还可以直接遍历文件对象获取每行:

for line in file_object:

process line

3.写文件

写文本文件

output = open(‘data‘, ‘w‘)

写二进制文件

output = open(‘data‘, ‘wb‘)

追加写文件

output = open(‘data‘, ‘w+‘)

写数据

file_object = open(‘thefile.txt‘, ‘w‘)

file_object.write(all_the_text)

file_object.close( )

写入多行

file_object.writelines(list_of_text_strings)

注意,调用writelines写入多行在性能上会比使用write一次性写入要高。

在处理日志文件的时候,常常会遇到这样的情况:日志文件巨大,不可能一次性把整个文件读入到内存中进行处理,例如需要在一台物理内存为 2GB 的机器上处理一个 2GB 的日志文件,我们可能希望每次只处理其中 200MB 的内容。

在 Python 中,内置的 File 对象直接提供了一个 readlines(sizehint) 函数来完成这样的事情。以下面的代码为例:

file = open(‘test.log‘, ‘r‘)sizehint = 209715200   # 200Mposition = 0lines = file.readlines(sizehint)while not file.tell() - position < 0:       position = file.tell()       lines = file.readlines(sizehint)

每次调用 readlines(sizehint) 函数,会返回大约 200MB 的数据,而且所返回的必然都是完整的行数据,大多数情况下,返回的数据的字节数会稍微比 sizehint 指定的值大一点(除最后一次调用 readlines(sizehint) 函数的时候)。通常情况下,Python 会自动将用户指定的 sizehint 的值调整成内部缓存大小的整数倍。

file在python是一个特殊的类型,它用于在python程序中对外部的文件进行操作。在python中一切都是对象,file也不例外,file有file的方法和属性。下面先来看如何创建一个file对象:

file(name[, mode[, buffering]])

file()函数用于创建一个file对象,它有一个别名叫open(),可能更形象一些,它们是内置函数。来看看它的参数。它参数都是以字符串的形式传递的。name是文件的名字。

mode是打开的模式,可选的值为r w a U,分别代表读(默认) 写 添加支持各种换行符的模式。用w或a模式打开文件的话,如果文件不存在,那么就自动创建。此外,用w模式打开一个已经存在的文件时,原有文件的内容会被清空,因为一开始文件的操作的标记是在文件的开头的,这时候进行写操作,无疑会把原有的内容给抹掉。由于历史的原因,换行符在不同的系统中有不同模式,比如在 unix中是一个\n,而在windows中是‘\r\n’,用U模式打开文件,就是支持所有的换行模式,也就说‘\r’ ‘\n‘ ‘\r\n‘都可表示换行,会有一个tuple用来存贮这个文件中用到过的换行符。不过,虽说换行有多种模式,读到python中统一用\n代替。在模式字符的后面,还可以加上+ b t这两种标识,分别表示可以对文件同时进行读写操作和用二进制模式、文本模式(默认)打开文件。

buffering如果为0表示不进行缓冲;如果为1表示进行“行缓冲“;如果是一个大于1的数表示缓冲区的大小,应该是以字节为单位的。

file对象有自己的属性和方法。先来看看file的属性。

closed #标记文件是否已经关闭,由close()改写

encoding #文件编码

mode #打开模式

name #文件名

newlines #文件中用到的换行模式,是一个tuple

softspace #boolean型,一般为0,据说用于print

file的读写方法:

F.read([size]) #size为读取的长度,以byte为单位

F.readline([size])

#读一行,如果定义了size,有可能返回的只是一行的一部分

F.readlines([size])

#把文件每一行作为一个list的一个成员,并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数,size是表示读取内容的总长,也就是说可能只读到文件的一部分。

F.write(str)

#把str写到文件中,write()并不会在str后加上一个换行符

F.writelines(seq)

#把seq的内容全部写到文件中。这个函数也只是忠实地写入,不会在每行后面加上任何东西。

file的其他方法:

F.close()

#关闭文件。python会在一个文件不用后自动关闭文件,不过这一功能没有保证,最好还是养成自己关闭的习惯。如果一个文件在关闭后还对其进行操作会产生ValueError

F.flush()

#把缓冲区的内容写入硬盘

F.fileno()

#返回一个长整型的”文件标签“

F.isatty()

#文件是否是一个终端设备文件(unix系统中的)

F.tell()

#返回文件操作标记的当前位置,以文件的开头为原点

F.next()

#返回下一行,并将文件操作标记位移到下一行。把一个file用于for ... in file这样的语句时,就是调用next()函数来实现遍历的。

F.seek(offset[,whence])

#将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的,一般为正数。但如果提供了whence参数就不一定了,whence可以为0表示从头开始计算,1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意,如果文件以a或a+的模式打开,每次进行写操作时,文件操作标记会自动返回到文件末尾。

F.truncate([size])

#把文件裁成规定的大小,默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大,依据系统的不同可能是不改变文件,也可能是用0把文件补到相应的大小,也可能是以一些随机的内容加上去。

来自为知笔记(Wiz)

时间: 2024-10-22 08:14:43

python13_day2的相关文章