数据类型 字符串 列表 元组 字典

数据类型 （共 7 种）

1.str  字符串类型（用发多）

2.int 数字类型

3.bool bool类型 (True 和 False)

4.list 列表（增删改查）

5.tuple 元组（增删改查）

6.dict 字典（增删改查）

7.set （还没学）

 

1.str (字符串类型) ：

1.1 介绍

在单引号、双引号、三引号内，由一串字符组成的叫字符串

1.2 字符串的索引与切片

字符串索引

s = 'ABCDEFGHIJK'
print(s[0]) #取第一位
>>> 'A'

print(s[2]) #取第三位
>>> 'C'

print(s[-1]) #取倒数第一位
>>>'K'

print(s[-2]) #取倒数第二位
>>> 'J'

 

 

字符串切片：顾头不顾尾

s = 'ABCDEFGHIJK' #切片打印 第一位 到 第三位
print(s[0:4])
>>>'ABCD'

print(s[0:-1]) #切片打印 第一位 到 倒数第二位
>>>'ABCDEFGHIJ'

print(s[:])     #切片打印 所有
>>>'ABCDEFGHIJK'

print(s[0:])     #切片打印 所有
>>>'ABCDEFGHIJK'

print(s[0:0])    #因为0:0 都是A 顾头不顾尾原则 所以不打印
>>>

s = 'ABCDEFGHIJK'  # s[首:尾:步长]
print(s[0:5:2])   #切片 跳着 打印 第一位 到 第四位
>>>'ACE'

print(s[4:0:-1])  #倒着打印时 步长必须加上-1
>>>'EDCB'

print(s[3::-1]) #倒着打印 第三位 到 A 所有字符串
>>>'DCBA'

print(s[3::-2]) #倒着 跳着打印
>>>'DB'

print(s[-1::-1]) #倒着 打印 所有
>>>'KJIHGFEDCBA'

print(s[::-1]) #简写 倒着打印 所有
>>>'KJIHGFEDCBA'

 

 

 

 

1.3 常用方法

 

 

 

s = 'pyTHon'
# captalize,swapcase,title
print(s.capitalize()) #将首字母变大写，后面字母变小写
>>>'Python'

print(s.swapcase()) #反转，大小写互换
>>>'PYthON'

s1 = '-python fullstack@s9' #每个单词首字母大写，由数字，空格等特殊字符隔开
print(s1.title())
>>>'-Python*Fullstack@S9'


# upper、lower
print(s.upper())
>>>'PYTHON'

print(s.lower())
>>>'python'

# center、expandtabs
print(s.center(20, '*'))
>>>'*******PytHOn*******'

# 在\t前面不全8或8的倍数个空格，如果有字符的话字符先顶头
s2 = '\tpython\tfullstack'
print(s2.expandtabs())
>>>'        python  fullstack'


# 公共方法len()
print(len(s))
>>>'6'


# startswith、endswith
print(s.startswith('py')) #判断是否已（自定义）开头，注意！！区分大小写！！！
>>>'True'

print(s.startswith('py', 0, 4)) #切片判断是否已（自定义）开头，注意！！区分大小写！！！
>>>'True'



print(s.endswith('oN')) #判断是否已（自定义）结尾，注意！！区分大小写！！！
>>>'False'

print(s.endswith('oN',0, 6)) #切片判断是否已（自定义）结尾，注意！！区分大小写！！！
>>>True


# find、index
print(s.find('h')) #查找所引值，找不到不报错，返回-1。注意！！区分大小写！！！
>>>3

print(s.index('h')) #查找所引值，找不到会报错。注意！！区分大小写！！！
>>>3



# strip rstrip lstrip
s3 = '  python '
print(s3.strip()) #去除空格 或者 去除两边的字符
>>>'python'

s3 = '  python@ '
print(s3.rstrip()) #只能去除右边的空格
>>>' python@'

s = ' @python*@ '
print(s.lstrip()) #只能去除左边的空格
>>>'@python*@ '

#replace #Python replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

#!/usr/bin/python

str = "this is string example....wow!!! this is really string";
print str.replace("is", "was");
print str.replace("is", "was", 3);

以上实例输出结果如下：
thwas was string example....wow!!! thwas was really string
thwas was string example....wow!!! thwas is really string

 

# is系列
name='python666'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成
print(name.isalnum()) #是否全是字母和数字，并至少有一个字符 
print(name.isspace()) #是否全是空白字符，并至少有一个字符 

 

# count
s5 = 'life is short we use python' #统计某一字符出现几次
print(s5.count('s'))
>>>3

# split
s6 = '我爱你你爱我我就在家' #以（自定义）分割，最终形成一个列表此列表不含有这个分割的元素。
print(s6.split('我'))
>>>['', '爱你你爱', '', '就在家']

# format 三种用法
s7 = '大家好我叫{}，我今年{}，我喜欢{}，再说一遍我叫{}'
print(s7.format('ELijah', 26, 'coding', 'Elijah'))
# >>>大家好我叫ELijah，我今年26，我喜欢coding，再说一遍我叫Elijah

s8 = '大家好我叫{0}，我今年{1}，我喜欢{2}，再说一遍我叫{0}'
print(s8.format('ELijah', 26, 'coding'))
# >>>大家好我叫ELijah，我今年26，我喜欢coding，再说一遍我叫Elijah

s9 = '大家好我叫{name}，我今年{age}，我喜欢{hobby}，再说一遍我叫{name}'
print(s9.format(hobby='coding', name='ELijah', age=26))
>>>大家好我叫ELijah，我今年26，我喜欢coding，再说一遍我叫Elijah

 

2.list(列表类型)

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

   2.2 常用方法

# list列表常用方法

# 增
# 在列表末尾添加元素
lst = ['C','Java','C++','Ruby','PHP']
lst.append('Python')
print(lst)
>>> ['C','Java','C++','Ruby','PHP','Python']

# 在指定索引前插入元素
lst = ['C','Java','C++','Ruby','PHP']
lst.insert(3,'Python')
print(lst)
>>> ['C','Java','C++','Python','Ruby','PHP']

# 以迭代的方式在列表末尾添加元素
lst = ['C','Java','C++','Ruby','PHP']
lst.extend('Python')
print(lst)
>>> ['C','Java','C++','Python','Ruby','PHP','P','y','t','h','o','n']

# 删
# 删除指定索引的元素，默认无索引则删除最后一个元素
lst = ['C','Java','C++','Ruby','PHP']
lst.pop(3)
print(lst)
>>> ['C','Java','C++','PHP']
# pop()有返回值，返回删除掉的元素
print(lst.pop(3))
>>> 'Ruby'

lst = ['C','Java','C++','Ruby','PHP'] #默认删除最后一个
lst.pop()
print(lst)
>>> ['C','Java','C++','Ruby']
# pop()有返回值，返回删除掉的元素
print(lst.pop())
>>> 'PHP'

# 删除指定元素
lst = ['C','Java','C++','Ruby','PHP']
lst.remove('Ruby')
print(lst)
>>> ['C','Java','C++','PHP']

# 清空列表所有元素
lst = ['C','Java','C++','Ruby','PHP']
lst.clear()
print(lst)
>>> []

# 删除列表
lst = ['C','Java','C++','Ruby','PHP']
del lst
print(lst)
>>> Traceback (most recent call last):
      File "D:practice.py", line 5, in <module>
        print(lst)
    NameError: name 'lst' is not defined

# 删除列表指定索引元素
lst = ['C','Java','C++','Ruby','PHP']
del lst[3:]
print(lst)
>>> ['C','Java','C++']

# 改
# 直接指定元素索引并赋予新值进行修改
lst = ['C','Java','C++','Ruby','PHP']
lst[3] = 'Python'
print(lst)
>>> ['C','Java','C++','Python','PHP']

# 利用切片进行迭代修改
lst = ['C','Java','C++','Ruby','PHP']
lst[3:] = 'Python'
print(lst)
>>> ['C','Java','C++','P','y','t','h','o','n']

# 查
# 通过循环迭代查询列表中元素
lst = ['C','Java','C++','Ruby','PHP']
for i in lst:
    print(i)

# 切片查询列表中一部分元素
lst = ['C','Java','C++','Ruby','PHP']
print(lst[0:3])
>>> ['C','Java','C++']

#---------------------------------------

# 列表排序
# 正序排序
lst = [4,3,2,5,7,8,9,1,6,0]
lst.sort()
print(lst)
>>> [0,1,2,3,4,5,6,7,8,9]

# 倒序排序
lst = [4,3,2,5,7,8,9,1,6,0]
lst.sort(reverse=True)
print(lst)
>>> [9,8,7,6,5,4,3,2,1,0]

# 翻转
lst = [4,3,2,5,7,8,9,1,6,0]
lst.reverse()
print(lst)
>>> [0,6,1,9,8,7,5,2,3,4]

#---------------------------------------

# 列表的嵌套
lst = ['C','Java','C++','Python','Ruby','PHP',['HTML','GO','R','Objective-C']]
# 需求：将"HTML"改为"JavaScript"
lst[-1][0] = 'JavaScript'
print(lst)
# 需求：将"PHP"改为"php"
lst[5] = lst[5].lower()
print(lst)

#---------------------------------------

# join()方法
# S.join():其中S是字符串连接符，join中参数必须是可迭代对象，join()方法输出可迭代对象的每一个元素，并用连接符将每一个元素连接
s = 'ilovepython'
l = ['C','Java','C++','Ruby','PHP','Python']
print('_'.join(s))
>>> 'i_l_o_v_e_p_y_t_h_o_n'
print('_'.join(l))
>>> 'C_Java_C++_Ruby_PHP_Python'

 

2.3 重要方法

 

# string <——> list : 字符串与列表的相互转换
# string ——> list : split()

s = 'i_l_o_v_e_p_y_t_h_o_n'
print(s.split('_'))
>>> ['i', 'l', 'o', 'v', 'e', 'p', 'y', 't', 'h', 'o', 'n']

# list ——> string : join() 
l = ['C','Java','C++','Ruby','PHP','Python']
print(''.join(l))
>>> CJavaC++RubyPHPPython

 

 

 

2.4 range()方法

# range:相当于都是数字的列表 [0,1,2,3,4.....,99]
# range(起始值，终止值)
for i in range(0,100):
    print(i)

# 默认起始值不写默认为0
for i in range(100):
    print(i)

# 同索引一样，range也可以加步长,加步长的话默认的0起始值就不可以省略
for i in range(0,100,2):
    print(i)

for i in range(100,0,-2):
    print(i)

# ★★★注意！面试题：不报错，也不输出结果！
'''
起始值:0
终止值:10
步长:-1
'''
for i in range(0,10,-1):
    print(i)

3.tuple(元组类型)

3.1 介绍
Python的元组与列表类似，同样可通过索引访问，支持异构，任意嵌套。不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

3.2 常用方法
Tuple(元组)与List（列表）方法相同，不同在于元组不能更改

 

4.dict(字典类型)

4.1 介绍
4.1.1 字典介绍
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根
据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变
类型，如：数字、字符串、元组。


4.1.2 数据类型划分：可变数据类型、不可变数据类型
    1.不可变数据类型：元组、布尔值、数值、字符串 ——> 不可变数据类型又称为可哈希
    2.可变数据类型：列表、字典、集合 ——>可变数据类型又称不可哈希


4.1.3 字典的特性
1.字典dict的key必须是不可变数据类型：元组、布尔值、数值、字符串
2.字典dict的value可以是任意数据类型
3.字典dict的优点：
    (1)二分查找查询
    (2)②存储大量的关系型数据
4字典的特点：无序的——>无索引

 

4.2 常用方法

 

dic = {'age': 26, 'name': 'yang', 'sex': 'male'}

# --------------------------------------------------------------------------
# 增 - 2种
dic['height'] = 180 # 如果没有键，则增加
>>> {'age': 26, 'name': 'yang', 'sex': 'male','height':180}
dic['age'] = 18 # 如果有键，则覆盖
>>> {'age': 18, 'name': 'yang', 'sex': 'male'}

dic.setdefault('height') # 如果没有键，则增加，且如果不写值vlaue，则默认None
>>> {'age': 26, 'name': 'yang', 'sex': 'male','height':None}
dic.setdefault('height', 185) # 如果没有键，则增加
>>> {'age': 26, 'name': 'yang', 'sex': 'male','height':185}
dic.setdefault('age', 185) # 如果有键，不覆盖
>>>{'age': 26, 'name': 'yang', 'sex': 'male'}

# --------------------------------------------------------------------------

# 删 - 4种
# ①
dic.pop('name1','No KEY') # 如果有没键，不报错，返回值会返回后面的参数文本
>>> print(dic.pop('name1','No KEY'))
>>> 'No KEY'
>>> print(dic)
>>> {'name': 'yang', 'sex': 'male', 'age': 26}

dic.pop('age') # 如果有键,则删除对应的键值对；返回值会返回删除掉的值value
>>> print(dic.pop('age'))
>>> 26
print(dic)
>>> {'sex': 'male', 'name': 'yang'}

# ②
dic.popitem() # 随机删除字典中的一组键值对
>>> {'name': 'yang', 'sex': 'male'}

# ③
del dic['height'] # 如果没有键，则报错
>>> Traceback (most recent call last):
      File "D:/python_fullstack_s9/day5/day5_课堂内容总结.py", line 31, in <module>
        del dic['height'] # 如果没有键，则报错
    KeyError: 'height'
del dic['age'] # 如果有键，则删除对应的键值对
>>> {'name': 'yang', 'sex': 'male'}

# ④
dic.clear() # 清空字典
>>> {}

# --------------------------------------------------------------------------

# 改 - 2种
# ①
dic['height'] = 185 # 如果没有键，则增加
>>> {'height': 185, 'age': 26, 'sex': 'male', 'name': 'yang'}

dic['age'] = 18 # 如果有键，则修改
>>> {'sex': 'male', 'name': 'yang', 'age': 18}

# ②
dic_new = {'lanuage':'PYTHON','addr':'昌平'}
dic.update(dic_new) # update(dict)，update的参数必须是键值对，将dic_new所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic中
>>> {'sex': 'male', 'addr': '昌平', 'lanuage': 'PYTHON', 'name': 'yang', 'age': 26}

# --------------------------------------------------------------------------

# 查 - 5种
# ①
dic.keys() # 获取字典的键，返回dict.keys的数据类型，相当于list

默认打印字典的键
for i in dic1:
    print(i)

for i in dic1.keys():
    print(i)

# ②
dic.values() # 获取字典的值，返回dict.values的数据类型，相当于list

默认打印字典的值
for i in dic1.values():
    print(i)

# ③
dic.items() # 获取字典的键和值，返回由keys和values组成的元组

默认打印字典的键值
for i in dic1.items():
    print(i)

for keys,values in dic1.items():
    print(keys,values)

# ④
dic.get('height','No KEY') # 如果没有键，则返回值为后面的参数文本
print(dic.get('height','No KEY'))
>>> No KEY

dic.get('age','No KEY') # 如果有键，则返回值为对应键的值
print(dic.get('age','No KEY'))
>>> 26

# ⑤
print(dic['height']) # 如果有没键，则报错
>>> Traceback (most recent call last):
      File "D:/python_fullstack_s9/day5/day5_课堂内容总结.py", line 79, in <module>
        print(dic['height']) # 如果有没键，则报错
    KeyError: 'height'

print(dic['age']) # 如果有键，则返回键对应的值
>>> 26

# --------------------------------------------------------------------------
# 字典的嵌套
dic = {
    'name':['a','b','c'],
    'age':43,
    'addr':{
        '1':1,
        '2':2,
    }
}

# 需求：在addr中加入'3':3这个键值对
dic['addr']['3'] = 3
print(dic)

 

 

5 公用方法

 

# 公共方法
# 统计元素长度
s = 'ilovepython'
l = ['C','Java','C++','Ruby','PHP','Python','C','JAVA']
print(len(s))
>>> 11
print(len(l))
>>> 8

# 统计元素出现的次数
s = 'ilovepython'
l = ['C','Java','C++','Ruby','PHP','Python','C','JAVA']
print(s.count('o'))
>>> 2
print(l.count('C'))
>>> 2

# 输出指定元素的索引值
s = 'ilovepython'
l = ['C','Java','C++','Ruby','PHP','Python','C','JAVA']
print(l.index('Java'))
>>> 1
print(s.index('e'))
>>> 4

 

转载于:https://www.cnblogs.com/lidaxu/p/8082247.html