python 常用语法及命令（一）列表 元组 字符串 序列操作

 

python 列表 []

1、插入 :append() 、extend、insert()、+

    1) append()  在尾后插入  

     extend() 连接两个链表

>>> list1 = [1,2,3,4]
>>> list2 = [5,6,7,8]
>>> list1.append(list2)
>>> list1
[1, 2, 3, 4, [5, 6, 7, 8]]
>>> list1 = [1,2,3,4]
>>> list1.extend(list2)
>>> list1
[1, 2, 3, 4, 5, 6, 7, 8]

append()和extend()的区别是append()是整个列表作为一个元素加入到列表list1中，extend()是把list2中所有的元素加入到list1中

  2)  insert() 指定插入位置,insert(n,elem),可以插入的是一个数值，列表字符串，任何类型的元素

>>> list1
[1, 1, 2, 3, 4, 5, 6, 7, 8]
>>> list1.insert(3,10)
>>> list1
[1, 1, 2, 10, 3, 4, 5, 6, 7, 8]
>>> list1.insert(3,list2)
>>> list1
[1, 1, 2, [5, 6, 7, 8], 10, 3, 4, 5, 6, 7, 8]
>>> str="abc"
>>> list1.insert(3,str)
>>> list1
[1, 1, 2, 'abc', [5, 6, 7, 8], 10, 3, 4, 5, 6, 7, 8]
>>> 

     + 号连接两个列表  效果和extend()相同

>>> l = l1+l2
>>> l
[1, 2, 3, 4, 5, 6]

     list * 3 列表内复制三遍

>>> l = l1 * 3
>>> l
[1, 2, 3, 1, 2, 3, 1, 2, 3]

2、删除 remove()、 del、pop()

     digitlist = [1, 2,' 3', 4, 5]

     digitlist.remove('3') #删除指定元素

     del digitlist[1]  #删除指定位置的元素

     name = list.pop() #默认弹出最后一个 栈 ；删除指定位置pop(1)

3、in、count、index、reverse、sort

      1)in 判断元素是否存在 ，不能判断列表中的列表 #可以 num in list[n] (取出列表的列表)

>>> l 
[1, 2, 3, 4, [5, 6, 7]]
>>> num = 3
>>> num in l
True
>>> num=6
>>> num in l
False
>>> num in l[4]
True

     2) list.count(num)    #count中的参数在列表中出现的次数

     3) index()  #index中参数在列表中首次出现的位置，返回元素下标.。index（123，3，7）3，7表示范围在第三到第七之前首次出现123的位置。注意index返回的是首次出现的位置，不是所有的位置

     3)reverse() #翻转列表

     4)sort() 排序   默认从小到大   sort(reverse=True)重大到小

4、切片

    值得注意的是切片拷贝 是拷贝  list1 = list[:]

    直接赋值只是多个引用  list1 =list 两个指向一个空间

 

python 元组 ()

 1、定义    元组不可改变元素

 定义元组的形式

    touple1 = (1) 不是元组  #type(touple1)

>>> tuple=(1)
>>> type(tuple)
<class 'int'>   #我们看到tuple是类型为int的整数1

    touple1 = 2，3，4，5  是

>>> tuple1 = 2,3,4,5
>>> type(tuple1)
<class 'tuple'>

    touple = （1,） 是

>>> tuple = (1,)
>>> type(touple)
<class 'tuple'>

    touple = 1,   是

>>> tuple = (1,)
>>> type(touple)
<class 'tuple'>

   所以元组的逗号(',')很关键

 8 *（8，） #（将元组(8,)元素复制8份，也就是8，8，8，8，8，8，8，8）

>>> 8*(8,)
(8, 8, 8, 8, 8, 8, 8, 8)
>>> 

2、间接改变 元组不允许修改增添和删除,但可以通过间接的方式更改

>>> temp = ('a','b','c','d')
>>> temp1 = temp
>>> temp = temp[0:2]+('z',)+temp[2:]
>>> temp
('a', 'b', 'z', 'c', 'd')
>>> temp1
('a', 'b', 'c', 'd') #temp1没有改变

注意这里，所谓的间接更改是指，原来的（'a', 'b', 'c', 'd'）并没有改变 ，只是标签temp重新指向了（'a', 'b', 'z','c', 'd'），（'a', 'b', 'c', 'd'）内存会被编译器回收

 

python 字符串

1、切片   #可以切片

2、字符  #python 字符就是长度为1的字符串

3、元素不能修改  类似元组 但可以使用列表很多方法

4、格式化   .format()

     位置参数

      "{0} love {1}.{2}".format("I","python","com") # 'I love python.com'

     关键字参数  

     "{a} love {b}.{b}".format(a="I",b="python",c="com")

     "{0} love {b}.{b}".format("I",b="python",c="com") #  位置参数必须在关键字参数之前

#命令行里直接打印字符串，print打印转义字符
>>> '\ta'
'\ta'
>>> print('\ta')
	a
>>> print('\\')
\

 #{{0}}不会打印出字符串
>>> "{0}".format("abc")
'abc'
>>> "{{0}}".format("abc")
'{0}'

#控制打印小数精度 四舍五入
>>> "{0:.1f}{1}".format(27.567,'GB')
'27.6GB'
>>> "{0:.1f}{1}".format(27.512,'GB')
'27.5GB'

5、format函数
对齐字符串,使用<,> 或者^字符后面紧跟一个指定的宽度 

>>> format(text, '>20')
' Hello World'
>>> format(text, '<20')
'Hello World '
>>> format(text, '^20')
' Hello World '

 如果你想指定一个非空格的填充字符，将它写到对齐字符的前面即可

>>> format(text, '=>20s')
'=========Hello World'
>>> format(text, '*^20s')
'****Hello World*****'

 当格式化多个值的时候，这些格式代码也可以被用在format() 方法中

 

>>> '{:>10s} {:>10s}'.format('Hello', 'World')
' Hello World'

format() 函数的一个好处是它不仅适用于字符串。它可以用来格式化任何值，使
得它非常的通用。比如，你可以用它来格式化数字：

>>> x = 1.2345
>>> format(x, '>10')
' 1.2345'
>>> format(x, '^10.2f')
' 1.23 '

字符串格式化符号含义

符号	说明
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数(大写)
%f	格式化定点数，可指定小数点后的精度
%e	用科学计数法格式化定点数
%E	作用同%e,用科学计数法格式化定点数
%g	根据值得大小决定使用%f或%e
%G	作用同%g,根据值得大小决定使用%f或者%e

 

 

>>> '%c' %97
'a'
>>> '%c %c %c' % (97,98,99)
'a b c'
>>> '%s' % 'abc'
'abc'
>>> '%d+%d = %d' % (1,2,1+2)
'1+2 = 3'
>>> '%o' % 10
'12'
>>> '%x' %10
'a'
>>> '%X' %10
'A'
>>> '%X' %16
'10'
>>> '%X' % 160
'A0'
>>> '%f' % 27.658
'27.658000'
>>> '%e' % 27.658
'2.765800e+01'
>>> '%E' % 27.658
'2.765800E+01'
>>> '%g' % 27.658
'27.658'

 格式化操作符

符号	说明
-	用于左对齐
+	在正数前面显示加号（+）
#	在八进制数前面显示零('0'),在十六进制数前面显示‘0x’或‘0 X’
0	显示的数字前面填充‘0’取代空格
m.n	m是显示的最小总宽度，n是小数点后的位数

 

 

>>> '%5.1f' % 27.658
' 27.7'
>>> '%.2e' % 27.658
'2.77e+01'
>>> '%10d' % 5
'         5'
>>> '%-10d' % 5
'5         '
>>> '%+d' % 5
'+5'
>>> '%-d' % 5
'5'
>>> '%+d' % -5
'-5'
>>> '%#o' % 10
'0o12'
>>> '%#X' % 108
'0X6C'
>>> '%#d' % 10
'10'
>>> '%010d' % 5
'0000000005'
>>> '%-010d' % 5
'5         '

 

字符串转义符含义

符号	说明
\'	单引号
\"	双引号
\a	发系统响铃声
\b	退格符
\n	换行符
\t	横向制表符
\v	纵向制表符
\r	回车符
\f	换页符
\o	八进制数代表的字符
\x	十六进制数代表的字符
\0	表示一个空字符
\\	反斜杠

5、各种函数操作

      (来自小甲鱼论坛)

capitalize()	把字符串的第一个字符改为大写
casefold()	把整个字符串的所有字符改为小写
center(width)	将字符串居中，并使用空格填充至长度 width 的新字符串
count(sub[, start[, end]])	返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。
encode(encoding='utf-8', errors='strict')	以 encoding 指定的编码格式对字符串进行编码。
endswith(sub[, start[, end]])	检查字符串是否以 sub 子字符串结束，如果是返回 True，否则返回 False。start 和 end 参数表示范围，可选。
expandtabs([tabsize=8])	把字符串中的 tab 符号（\t）转换为空格，如不指定参数，默认的空格数是 tabsize=8。
find(sub[, start[, end]])	检测 sub 是否包含在字符串中，如果有则返回索引值，否则返回 -1，start 和 end 参数表示范围，可选。
index(sub[, start[, end]])	跟 find 方法一样，不过如果 sub 不在 string 中会产生一个异常。
isalnum()	如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True，否则返回 False。
isalpha()	如果字符串至少有一个字符并且所有字符都是字母则返回 True，否则返回 False。
isdecimal()	如果字符串只包含十进制数字则返回 True，否则返回 False。
isdigit()	如果字符串只包含数字则返回 True，否则返回 False。
islower()	如果字符串中至少包含一个区分大小写的字符，并且这些字符都是小写，则返回 True，否则返回 False。
isnumeric()	如果字符串中只包含数字字符，则返回 True，否则返回 False。
isspace()	如果字符串中只包含空格，则返回 True，否则返回 False。
istitle()	如果字符串是标题化（所有的单词都是以大写开始，其余字母均小写），则返回 True，否则返回 False。
isupper()	如果字符串中至少包含一个区分大小写的字符，并且这些字符都是大写，则返回 True，否则返回 False。
join(sub)	以字符串作为分隔符，插入到 sub 中所有的字符之间。
ljust(width)	返回一个左对齐的字符串，并使用空格填充至长度为 width 的新字符串。
lower()	转换字符串中所有大写字符为小写。
lstrip()	去掉字符串左边的所有空格
partition(sub)	找到子字符串 sub，把字符串分成一个 3 元组 (pre_sub, sub, fol_sub)，如果字符串中不包含 sub 则返回 ('原字符串', '', '')
replace(old, new[, count])	把字符串中的 old 子字符串替换成 new 子字符串，如果 count 指定，则替换不超过 count 次。
rfind(sub[, start[, end]])	类似于 find() 方法，不过是从右边开始查找。
rindex(sub[, start[, end]])	类似于 index() 方法，不过是从右边开始。
rjust(width)	返回一个右对齐的字符串，并使用空格填充至长度为 width 的新字符串。
rpartition(sub)	类似于 partition() 方法，不过是从右边开始查找。
rstrip()	删除字符串末尾的空格。
split(sep=None, maxsplit=-1)	不带参数默认是以空格为分隔符切片字符串，如果 maxsplit 参数有设置，则仅分隔 maxsplit 个子字符串，返回切片后的子字符串拼接的列表。
splitlines(([keepends]))	在输出结果里是否去掉换行符，默认为 False，不包含换行符；如果为 True，则保留换行符。。
startswith(prefix[, start[, end]])	检查字符串是否以 prefix 开头，是则返回 True，否则返回 False。start 和 end 参数可以指定范围检查，可选。
strip([chars])	删除字符串前边和后边所有的空格，chars 参数可以定制删除的字符，可选。
swapcase()	翻转字符串中的大小写。
title()	返回标题化（所有的单词都是以大写开始，其余字母均小写）的字符串。
translate(table)	根据 table 的规则（可以由 str.maketrans('a', 'b') 定制）转换字符串中的字符。
upper()	转换字符串中的所有小写字符为大写。
zfill(width)	返回长度为 width 的字符串，原字符串右对齐，前边用 0 填充。

#. join()：连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
>>> a=['1','2','3','4','5'] #列表
>>> '.'.join(a)
'1.2.3.4.5'

>>> b='hello world' #字符串
>>> '  '.join(b)
'h  e  l  l  o     w  o  r  l  d'
>>> ':'.join(b)
'h:e:l:l:o: :w:o:r:l:d'

>>> c=('1','2','3','4','5') #元组
>>> ' '.join(c)
'1 2 3 4 5'
>>> '-'.join(c)
'1-2-3-4-5'

>>> d={'name1':'a','name2':'b','name3':'c','name4':'d'} #字典
>>> '  '.join(d)
'name3  name4  name1  name2'
>>> '-'.join(d)
'name3-name4-name1-name2'

python 序列

元组、列表、字符串都成为序列下面的方法都适用

1、list()   返回一个列表,可以创建一个空列表，也可以将字符串、元组转换成列表

>>> l = list() #创建一个空列
>>> l
[]

>>> l1 = 'abcdef'
>>> l1 = list(l1) #将字符串转换成列表
>>> l1
['a', 'b', 'c', 'd', 'e', 'f']

>>> l2 = (1,2,3,4,5)
>>> l2 = list(l2) #将元组转换成列表
>>> l2
[1, 2, 3, 4, 5]

 2、tuple()  返回一个元组

3、str()  返回一个字符串

str()将列表和元组的[]和()也变为一个字符

>>> l1 = [1,2,3,4]
>>> l1 = str(l1)
>>> l1
'[1, 2, 3, 4]'
>>> l2 = (1,2,3,4)
>>> l2 = str(l2)
>>> l2
'(1, 2, 3, 4)'
>>> l2[0]
'('

4、len() 返回序列长度

>>> len(l1)#上面的了l1不仅[]当作一个字符，还在每个，后加了空格
12
>>> len(l2)#元组也是
12

5、max()  返回序列或者参数中最大值

6、min() 返回最小值  数据类型要是一样的

7、sum() 求和 同类型

>>> numbers = [1,2,3,4,5]
>>> sum(numbers)
15
>>> sum(numbers,3)
18
>>> chars = '123456'
>>> sun(chars)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'sun' is not defined

8、sorted()  排序 不改变原序列

>>> l1 = [1,5,3,9,6,4,20,15]
>>> sorted(l1)
[1, 3, 4, 5, 6, 9, 15, 20]

9、reversed() 反转  不改变原序列

reversed()的返回值要加list()转为列表

>>> l1
[1, 5, 3, 9, 6, 4, 20, 15]
>>> reversed(l1)
<list_reverseiterator object at 0x7fd7136a9f28>
>>> type(reversed(l1))
<class 'list_reverseiterator'>
>>> list(reversed(l1))
[15, 20, 4, 6, 9, 3, 5, 1]

10、enumerate() 枚举 不改变原序列

>>> l1
[1, 5, 3, 9, 6, 4, 20, 15]
>>> enumerate(l1)
<enumerate object at 0x7fd7136b2fc0>
>>> list(enumerate(l1))
[(0, 1), (1, 5), (2, 3), (3, 9), (4, 6), (5, 4), (6, 20), (7, 15)]

为了按传统行号输出(行号从1 开始)，你可以传递一个开始参数：

>>> my_list = ['a', 'b', 'c']
>>> for idx, val in enumerate(my_list, 1):
... print(idx, val)
...
1 a
2 b
3 c

这种情况在你遍历文件时想在错误消息中使用行号定位时候非常有用：

def parse_data(filename):
    with open(filename, 'rt') as f:
        for lineno, line in enumerate(f, 1):
            fields = line.split()
            try:
                count = int(fields[1])
                ...
            except ValueError as e:
                print('Line {}: Parse error: {}'.format(lineno, e))

enumerate() 对于跟踪某些值在列表中出现的位置是很有用的。所以，如果你想将一个文件中出现的单词映射到它出现的行号上去，可以很容易的利用enumerate() 来完成： 

word_summary = defaultdict(list)

with open('myfile.txt', 'r') as f:
    lines = f.readlines()

for idx, line in enumerate(lines):
    # Create a list of words in current line
    words = [w.strip().lower() for w in line.split()]
    for word in words:
        word_summary[word].append(idx)

当你想额外定义一个计数变量的时候，使用enumerate() 函数会更加简单 

 还有一点可能并不很重要，但是也值得注意，有时候当你在一个已经解压后的元组
序列上使用enumerate() 函数时很容易调入陷阱。

data = [ (1, 2), (3, 4), (5, 6), (7, 8) ]
# Correct!
for n, (x, y) in enumerate(data):
...
# Error!
for n, x, y in

11、zip()   看示例

>>> l1 = [1,2,3,4,5]
>>> l2 = [4,5,6,7,8]
>>> zip(l1,l2)
<zip object at 0x7fd713634548>
>>> list(zip(l1,l2))
[(1, 4), (2, 5), (3, 6), (4, 7), (5, 8)]

使用zip()迭代多个对象

>>> xpts = [1, 5, 4, 2, 10, 7]
>>> ypts = [101, 78, 37, 15, 62, 99]
>>>
>>> for x, y in zip(xpts, ypts):
...     print(x,y)
...
1 101
5 78
4 37
2 15
10 62
7 99

zip(a, b) 会生成一个可返回元组(x, y) 的迭代器，其中x 来自a，y 来自b。一旦其中某个序列到底结尾，迭代宣告结束。因此迭代长度跟参数中最短序列长度一致。

>>> a = [1, 2, 3]
>>> b = ['w', 'x', 'y', 'z']
>>> for i in zip(a,b):
... print(i)
...
(1, 'w')
(2, 'x')
(3, 'y')

 可以使用itertools.zip_longest() 函数

>>> from itertools import zip_longest
>>> for i in zip_longest(a,b):
... print(i)
...
(1, 'w')
(2, 'x')
(3, 'y')
(None, 'z')
>>> for i in zip_longest(a, b, fillvalue=0):
... print(i)
...
(1, 'w')
(2, 'x')
(3, 'y')
(0, 'z')

当你想成对处理数据的时候zip() 函数是很有用的。比如，假设你头列表和一个值列表，就像下面这样：

headers = ['name', 'shares', 'price']
values = ['ACME', 100, 490.1]

使用zip() 可以让你将它们打包并生成一个字典：s = dict(zip(headers,values))   

或者你也可以像下面这样产生输出：

for name, val in zip(headers, values):
print(name, '=', val)

zip() 可以接受多于两个的序列的参数。这时候所生成的结果元组中元素个数跟输入序列个数一样。

>>> a = [1, 2, 3]
>>> b = [10, 11, 12]
>>> c = ['x','y','z']
>>> for i in zip(a, b, c):
... print(i)
...
(1, 10, 'x')
(2, 11, 'y')
(3, 12, 'z')