python之路--第二天：基本数据类型即其方法介绍

计算机进制的故事

 

 

基本数据类型：字符串str   整型数字int   集合set   列表list  元组tuple  字典dict

###########str 字符串############

字符串默认是不可改变的，所以对字符串的修改，会重新生成一个新的字符串，原来的字符串不会改变。

快速查看字符串的方法

name = "tony"

>>>dir(name)  会列出name这个字符串的所有方法

>>>help(name.split)  查看name这个字符串的split方法

字符串str相当于一个类，其中的方法相当于一个实例化的对象

name = "alex"   str类的对象

1、name.capitalize()  首字母变大写，同时，如果字符串后面有大写字母，也会将大写转为小写，字符串默认是不可改变的，会生成一个新的值。

>>> name = "alex"
>>> name1 = name.capitalize()
>>> name1
'Alex'
>>> name = "aleX"
>>> name1=name.capitalize()
>>> name1
'Alex'

2、name.casefold() 将大写字母转为小写，可以转换多种语言。

>>> name="LIFuqianG"
>>> name1 = name.casefold()
>>> name1
'lifuqiang'

3、name.count("a")  统计字符串中a重复出现的次数

>>> name="alexalexalex"
>>> name.count("a")
3

4、name.format() 格式化输出

>>> name="我叫{0}，我今年{1}岁"
>>> v = name.format("李富强","25")
>>> print
>>> print(v)
我叫李富强，我今年25岁
>>> name = "我叫{name}，我今年{age}岁"
>>> v=name.format(name="李富强",age="25")
>>> print(v)
我叫李富强，我今年25岁
>>> 

5、name.startswith("a") 判断字符串是否以a开头，如果是，返回True，否则，返回false

>>> name = "Lifuqiang"
>>> name.startswith("L")
True
>>> name.startswith("l")
False

6、name.endswith("a") 判断字符串是否以a结尾，如果是，返回True，否则，返回false,同startswith方法，这里不再演示。

7、name.split("x")  将字符串以x为分隔符分割进行分割，生成一个不包含x的列表 

>>> name = "wo shi yi ge bin"
>>> v = name.split()
>>> print(v)
['wo', 'shi', 'yi', 'ge', 'bin']
>>> name = "lifuqiang"
>>> v = name.split("q")
>>> print(v)
['lifu', 'iang']

8、name.find("l")  查找l在字符串中的索引，如果字符存在于字符串中，则返回字符的索引，不存在，则返回-1

9、name.index("l")  查找l的索引，如果存在，则返回索引值，如果不存在，报错

>>> name.find("b")
-1
>>> name.find("q")
4
>>> name.index("a")
6
>>> name.index("b")
Traceback (most recent call last):
  File "<pyshell#69>", line 1, in <module>
    name.index("b")
ValueError: substring not found

10、name.replace("a","AA")  将字符串中的a替换为AA

>>> name = "你大爷的，你怎么搞得"
>>> name
'你大爷的，你怎么搞得'
>>> v = name.replace("你大爷的","***")
>>> print(v)
***，你怎么搞得

11、name.lower()  将字符串中的大写字母转为小写

12、name.upper() 将字符串中的小写转为大写

>>> name = "LiFuQiang"
>>> v = name.lower()
>>> print(v)
lifuqiang
>>> v1 = name.upper()
>>> print(v1)
LIFUQIANG

13、name.ljust(20,"#") 一共20个字符，alex位于左侧，后面被#填充

14、name.rjust(20,"#") 一共20个字符，alex位于右侧，前面被#填充

15、name.center(20,"#") 一共20个字符，alex居中，两侧被"#"填充

16、name.zfill(20) 一共20个字符，alex前面被0填充

17、join的使用**元素拼接，循环每一个元素

>>> name = "lifuqiang"
>>> v = "_".join(name)
>>> print(v)
l_i_f_u_q_i_a_n_g

18、partition("l")  将字符串以*为分割对象进行分割，生成一个包含l元素的列表，例如

name = "zhongguo"

v = name.partition("g")

print(v)输出的结果如下：

('zhon', 'g', 'guo')

19、name.swapspace() 大小写转换，大写的变成小写，小写的变成大写。

20、name.strip() 去除字符串两边的空格，但是不包括字符串当中的空格，

21、name.lstrip()  去除左边的空格

22、name.rstrip() 去除右边的空格。

23、name.isdigit()   判断字符串是否为全部数字，如果是，返回True，否则，返回False，例如：

name = "123456"

print(type(name))

v = name.isdigit()

print(type(v))

print(v)

输出结果如下：

<class 'str'>
<class 'bool'>
 True
24、name.isalnum()  判断是否为字符，数字，或者汉字，如果是，返回True，如果不是，返回False

25、name.isalpha()  判断字符串是否全部为英文字母，是，返回True，不是，则返回False。

26、name.decimal() 判断字符串是否全部为十进制数字，是，返回True，否则，返回False。

27、expandtabs  该方法把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。

    expandtabs()方法语法：str.expandtabs(tabsize=8)，tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数。

    该方法返回字符串中的 tab 符号('\t')转为空格后生成的新字符串。例如

    name = "Tom\tBob\tLinux"

    v = name.expandtabs(tabsize=20)

    print(v),输出结果如下

    'Tom                 Bob                 Linux'，将\t转为20个空格

28、name.isupper() 判断字符串包含的字母是否全部为大写，如果是，返回True,否则，返回False，可以包含汉字及数字。

29、name.islower()  判断字符串包含的字母是否全部为小写，如果是，返回True,否则，返回False，可以包含汉字及数字。

30、name.istitle()  判断字符串是否每个词组以大写字母开头，如果是，返回True，否则，返回False。可以包含数字及汉字

31、name.rindex("x") 从后面往前面查找，打印第一个x的索引。如果查找的元素不存在，报错。

32、name.rfind("x") 从后面往前面查找，打印第一个x的索引。如果查找的元素不存在，返回-1.

这里需要强调的是，字符串对象是不可改变的，也就是说在python创建一个字符串后，你不能把这个字符中的某一部分改变。任何上面的函数改变了字符串后，都会返回一个新的字符串，原字串并没有变。

33、翻译 maketrans()

该方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

注：两个字符串的长度必须相同，为一一对应的关系。

###########list 列表############

列表是我们最以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作。

1、定义列表

name = ["张三丰","光明左使","鹰王","青翼蝠王"]

2、name.append("紫衫龙王")：在列表末尾添加紫衫龙王

>>> name.append("紫衫龙王")
>>> name
['张三丰', '光明左使', '鹰王', '青翼蝠王', '紫衫龙王']

3、name.count("张三丰")：统计元素张三丰在列表中出现的次数

>>> name.count("张三丰")
1

4、name.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

>>> seq = [1,2,3]
>>> name.extend(seq)
>>> name
['张三丰', '光明左使', '鹰王', '青翼蝠王', '紫衫龙王', 1, 2, 3]

5、name.index("鹰王")：从列表中找出某个值第一个匹配项的索引位置,默认显示第一个匹配项的索引。

>>> name.index("鹰王")
2

6、name.insert(2, "金毛狮王")：将对象金毛狮王插入列表索引2的位置

>>> name.insert(2, "金毛狮王")
>>> name
['张三丰', '光明左使', '金毛狮王', '鹰王', '青翼蝠王', '紫衫龙王', 1, 2, 3]

7、name.pop()：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

>>> name
['张三丰', '光明左使', '金毛狮王', '鹰王', '青翼蝠王', '紫衫龙王', 1, 2, 3]
>>> name.pop()
3
>>> name
['张三丰', '光明左使', '金毛狮王', '鹰王', '青翼蝠王', '紫衫龙王', 1, 2]

8、name.remove("鹰王")：移除列表中鹰王的第一个匹配项

>>> name.remove("鹰王")
>>> name
['张三丰', '光明左使', '金毛狮王', '青翼蝠王', '紫衫龙王', 1, 2]

9、name.reverse()&name.sort()：反向列表中元素& 对原列表进行排序

>>> 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.copy()  拷贝name这个列表，浅拷贝

>>> name
['光明左使', '张三丰', '紫衫龙王', '金毛狮王', '青翼蝠王']
>>> name1 = name.copy()
>>> name1
['光明左使', '张三丰', '紫衫龙王', '金毛狮王', '青翼蝠王']

12、name.clear() 清空列表

>>> name
['光明左使', '张三丰', '紫衫龙王', '金毛狮王', '青翼蝠王']
>>> name.clear()
>>> name
[]

 

####################tuple  元组####################

元组与列表类似，不同之处在于元组的元素不能修改,元组使用小括号,列表使用方括号,元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可,元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义

1、创建元组

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

创建空元组

tup1 = ();

元组中只包含一个元素时，需要在元素后面添加逗号来消除歧义

tup1 = (50,)

2、访问元组：

元组同列表一样可以使用下标索引来访问元组中的值，如下实例:

#!/usr/bin/python

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );

 

print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
#以上实例输出结果：
#tup1[0]:  physics
#tup2[1:5]:  [2, 3, 4, 5]

三、修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

#!/usr/bin/python

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');

# 以下修改元组元素操作是非法的。
# tup1[0] = 100;

# 创建一个新的元组
tup3 = tup1 + tup2;
print（tup3）;
#以上实例输出结果：
#(12, 34.56, 'abc', 'xyz')

 

四、删除元素
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

name = ("bob","tom","jerry")

del  name

五、元组的运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组

六、元组索引
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素.

七、元组中嵌套列表

 例如name = ("bob","tom",["zhangsan","lisi"],"lili")

 对于整个元组来说，不可更改，但是对于元组中的列表，是可以改的。

八、元组的内置函数
元组包含了以下内置函数
1、cmp(tuple1, tuple2)：比较两个元组元素。
2、len(tuple)：计算元组元素个数。
3、max(tuple)：返回元组中元素最大值。
4、min(tuple)：返回元组中元素最小值。
5、tuple(seq)：将列表转换为元组

 

####################dict  字典#############################

1. 清空  clear
dic = {'k1':'v1','k2':'v2'}
dic.clear()
print(dic)

2. 浅拷贝copy
dic = {'k1':'v1','k2':'v2'}
v = dic.copy()
print(v)

3. 根据key获取指定的value；不存在不报错，可以指定返回的值
dic = {'k1':'v1','k2':'v2'}
v = dic.get('k1111',1111)  1111即为指定的返回值
print(v)
v = dic['k1111']
print(v)

4. 删除并获取对应的value值
dic = {'k1':'v1','k2':'v2'}
v = dic.pop('k1')
print(dic)
print(v)

5. 随机删除键值对，并获取到删除的键值
dic = {'k1':'v1','k2':'v2'}
v = dic.popitem()
print(dic)
print(v)

k,v = dic.popitem() # ('k2', 'v2')
print(dic)
print(k,v)

v = dic.popitem() # ('k2', 'v2')
print(dic)
print(v[0],v[1])

6. 增加，如果存在则不做操作
dic = {'k1':'v1','k2':'v2'}
dic.setdefault('k3','v3')
print(dic)
dic.setdefault('k1','1111111')
print(dic)

7. 批量增加或修改
dic = {'k1':'v1','k2':'v2'}
dic.update({'k3':'v3','k1':'v24'})
print(dic)


dic = dict.fromkeys(['k1','k2','k3'],123)
print(dic)
dic = dict.fromkeys(['k1','k2','k3'],123)
dic['k1'] = 'asdfjasldkf'
print(dic)

dic = dict.fromkeys(['k1','k2','k3'],[1,])
{
   k1: 123123213, # [1,2]
   k2: 123123213, # [1,]
   k3: 123123213, # [1,]
}
dic['k1'].append(222)
print(dic)
########## 额外：
 - 字典可以嵌套
 - 字典key: 必须是不可变类型
dic = {
    'k1': 'v1',
     'k2': [1,2,3,],
     (1,2): 'lllll',
     1: 'fffffffff',
     111: 'asdf',
 }
 print(dic)
 key:
     - 不可变
     - True,1
dic = {'k1':'v1'}
del dic['k1']

布尔值：
1 True
0 False
bool(1111)

########################### set  集合  ##############################

set 顾明思义，就是个集合，集合的元素是唯一的，无序的。一个{ }里面放一些元素就构成了一个集合，set里面可以是多种数据类型（但不能是列表，集合，字典，可以是元组）

1、定义集合：

>>>set1 = {1,2,3,4,5,6,2,3,4}

>>>type(set1)

<class 'set'>

>>>print(set1)

{1, 2, 3, 4, 5, 6},

可以看出，集合是没有重复的元素的。

2、set1 = {1,2,3,4,}

   set1.add(x)  将元素x加入到set1中，若元素已存在，不做任何操作

3、set1 = {1,2,3,4,}

   set1.update(x)  将集合x并入原集合s中，x还可以是列表，元组，字典等，x 可以有多个，用逗号分开。例如：

   >>>x = [12,23,34]

   >>>set1.update(x)

   >>>print(set1)

   {1, 2, 3, 4, 5, 6, 34, 12, 23}

4、set1 = {1,2,3,4,}

   set1.discart(x)  删除元素，如果元素不存在，不会引发错误，remove则不同，如果元素不存在，会报KeyError的错误

5、 set1 = {1,2,3,4,}

    set1.pop() 随机删除并返回集合s中某个值，注意，因为set是无序的，不支持下标操作，没有所谓的最后一个，pop()移除随机一个元 素并返回删除的元素值，这和其他数据结构不同

6、 set1 = {1,2,3,4,5}

    set1.clear()  清空集合。len(set1) 显示元素个数

7、set1 = {1,2,3,4,}

   x  in  set1  判断元素是否存在于集合中，如果返回True,说明存在，False，则不存在

8、set1 = {1,2,3,4,}

   set1.union(x) 返回s与集合x的交集，不改变原集合s，x 也可以是列表，元组，字典。

9、set1.intersection(x) 返回s与集合x的并集，不改变s， x 也可以是列表，元组，字典。

10、set1.difference(x) 返回在集合s中而不在集合 x 中的元素的集合，不改变集合s， x 也可以是列表，元组，字典。

11、set1.symmetric_difference( x ) 返回s和集合x的对称差集，即只在其中一个集合中出现的元素，不改变集合s， x 也可以是列表，元组，字典。

12、set1.issubset(x) 判断 集合set1 是否是集合x的子集，即set1是否被x集合包含，如果是，返回True,否则，返回False

    set1.issuperset(x) 判断集合set1是否是集合x的父集，即set1是否被包含集合x，如果是，返回True,否则，返回False

13、求交集，并集，差集，对称差集的另一种方法

s1 = {1,2,3,'a'}

s2 = {3,4,'b'}

s1 & s2  #交集  {3}

s1 | s2   #并集  {1, 'a', 3, 4, 'b', 2} 

s1 - s2  #差集   {1, 'a', 2} 

s1 ^ s2  #对称差集  {1, 2, 4, 'b', 'a'} 

{ } 在布尔运算中表示 False，其他均为 True