数据分析_Python学习02（集合不能重复，元祖不能改变）

1. 字符串
   单引号，双引号，三引号保卫起来的字符组就是字符串

my_str = 'hello'
#  h  e  l  l  o
#  0  1  2  3  4    正向索引
# -5 -4 -3 -2 -1    反向索引

# 1. 根据索引获取对应的值
my_str = 'hello'
print(my_str[0])    # h
print(my_str[2])    # l
print(my_str[4])    # o
print(my_str[-1])    # o 反向
print('*'*20)

# 2. 取最后一位的值
my_str = 'hello'
# 方法一：根据索引取值
print(my_str[4])    # o
print(my_str[-1])    # o
# 方法二：使用len()方法
print(my_str[len(my_str)-1])    # o

'''
len():
len()方法返回对象（字符、列表、元祖等）长度和个数
'''

# 3. 字符串的切片
# 根据下标的范围获取部分值
# 数据[起始下标:结束下标:步长]  步长默认为1，不包含结束下标 [)
my_str = 'hello'
print(my_str[1:3])  # el
print(my_str[1:])  # ello   从某个位置截取到最后
print(my_str[:3])  # hel    从开头截取到某个位置
print(my_str[1:-1])  # ell

# 4. 字符串常见的内置函数
new_str = 'hello python'
# 4.1 capitalize()将字符串的第一个字母变成大写 title()所有单词都是以大写开始
print(new_str.capitalize(), new_str.title())
# 输出 Hello python Hello Python

# 4.2 upper()将所有字母变成大写 upper()将所有字母变成小写
print(new_str.upper())  # HELLO PYTHON
print(new_str.lower())  # hello python

# 4.3 startswith()用于检查字符串是否是以指定子字符串开头
url_addr = 'http://taobao.com'
print(url_addr.startswith('http://'))   # True
print(url_addr.endswith('.com'))    # True

# 4.4 count()用于统计字符串里某个字符出现的次数
print(new_str.count('h'))   # 2

# 4.5
# isdigit()检测字符串是否只由数字组成
# isalpha()方法检测字符串是否只由字母组成
# isalnum()检测字符串是否由字母和数字组成
print('123'.isdigit())  # True
print('abc'.isalpha())  # True
print('123abc'.isalnum())  # True

# 5. 字符串的遍历 for ... in ...
my_str = 'hello'
for value in my_str:
    print(value)

# enumerate：用于将一个可遍历的数据对象(如列表、元组或字符串)
# 组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中
for index, value in enumerate(my_str):
    print(index, value)

2. 列表（list）

定义：
	python内置的一种数据类型
    一种有序的集合
    可以随时添加和删除其中的元素
    列表内的项目之间用逗号隔开
    列表内的项目不必全是相同的类型
    例如：list = ['zs', '123', 99, True]

# 1. 根据索引取值
my_list = [1, 1.25, 'abc', False]
print(my_list[1])   # 1.25
print(my_list[len(my_list)-1])  # False

# 2. 切片
my_list = [1, 1.25, 'abc', False]
print(my_list[0: 3])    # [1, 1.25, 'abc']

# 3. 列表的增删查改
# 空列表
new_list = []
# new_list = list() 另一种创建空列表的方式

# 追加
new_list.append(1)
print(new_list)     # [1]

new_list.append('abc')
print(new_list)     # [1, 'abc']

# 插入
new_list.insert(0, True)
print(new_list)     # [True, 1, 'abc']

# 将两个列表的值进行合并
new_list1 = ['python', 'java']
new_list.extend(new_list1)
print(new_list)     # [True, 1, 'abc', 'python', 'java']

# 修改
new_list[0] = False
print(new_list)     # [False, 1, 'abc', 'python', 'java']

# 删除指定的数据
new_list.remove('abc')
print(new_list)     # [False, 1, 'python', 'java']

del new_list[0]
print(new_list)     # [1, 'python', 'java']

# 清空列表
new_list.clear()
print(new_list)     # []

# in / not in
print('a' in new_list)      # False

# count
print(new_list.count('a'))      # 0

# 通过值查找索引
print(new_list1.index('java'))      # 1

# 遍历（和字符串类似）
alist = [1, 2, 3, 4, 5, 6]
for value in alist:
    print(value)

for index, value in enumerate(alist):
    print(index, value)

3. 元祖（tuple）

有序的
    不能修改、删除，其他的和列表相同
注意：元祖内部存储的东西是不能修改的，但是如果存储的是一块地址（如：列表）则是可以修改的
栗子：my_tuple = (1, '23', True, [1, 3])

# 获取
print(my_tuple[0])      # 1

# 不可以修改
# my_tuple[0] = 'c'       # 报错

# 也不可以删除
# del my_tuple[2]       # 报错

# 但是，如果元祖内有存储地址，比如列表，那么这个地址（列表等）是可以修改的
print(my_tuple[-1])     # [1, 3]
my_tuple[-1][0] = ['a']     # 将列表中下标为0的元素改为'a'
print(my_tuple)     # (1, '23', True, [['a'], 3])

# my_tuple[-1] = ['a', 'b]      # 报错

# 遍历
new_tuple = ('a', 'b', 'c')
for value in new_tuple:
    print(value)
'''
a
b
c
'''

for index, value in enumerate(new_tuple):
    print(index, value)
'''
0 a
1 b
2 c
'''

# 注意点：只有一个元素的时候，需要加上逗号
atuple = (1)
print(type(atuple))     # <class 'int'>

btuple = (1,)
print(type(btuple))     # <class 'tuple'>

# 创建空元祖
ctuple = ()
print(ctuple)       # ()
print(type(ctuple))     # <class 'tuple'>

4. 字典（dict）

字典：
    dict
    可变的
    可存储任意类型的对象
    无序，用键值对表示：key:value,每对之间用逗号分隔
    {}
    key唯一，不重复

# 获取值
my_dict = {'name': 'sz', 'age': 30, 'score': 90}
print(my_dict['name'])      # sz
print(my_dict.get('name'))      # sz
# print(my_dict['nam'])      报错
print(my_dict.get('nam'))      # None

# 获取字典所有的key
print(my_dict.keys())       # dict_keys(['name', 'age', 'score'])

# 获取字典所有的value
print(my_dict.values())     # dict_values(['sz', 30, 90])

# 空字典
adict = {}
print(adict)        # {}

bdict = dict()
print(bdict)        # {}

# 添加
my_dict = {'name': 'sz', 'age': 30, 'score': 90}
my_dict['height'] = 190
print(my_dict)      # {'name': 'sz', 'age': 30, 'score': 90, 'height': 190}

# 修改
my_dict = {'name': 'sz', 'age': 30, 'score': 90}
my_dict['name'] = 'zf'
print(my_dict)      # {'name': 'zf', 'age': 30, 'score': 90, 'height': 190}

# 删除
my_dict = {'name': 'sz', 'age': 30, 'score': 90}
my_dict.pop('height')
print(my_dict)      # {'name': 'zf', 'age': 30, 'score': 90}

del my_dict['score']
print(my_dict)      # {'name': 'zf', 'age': 30}

# 清除
my_dict = {'name': 'sz', 'age': 30, 'score': 90}
my_dict.clear()
print(my_dict)      # {}

# in / not in
# 判断key
new_dict = {'name': 'zf', 'age': 30}
print('name' in new_dict)       # True
print('name' in new_dict.keys())       # True

# 判断value
print('zf' in new_dict.values())        # True

# 遍历
# 方法一
ddict = {'name': 'sz', 'age': 30, 'score': 90}
for key in ddict:
    print(key, ddict[key])

# 方法二
for key, value in ddict.items():
    print(key, value)

5. 集合（set）

集合：
    set
    无序（没有索引）
    不重复
    {}

# 创建集合用{}或set()函数
# 注意：创建一个空集合必须用set()，不能用{}，因为{}是用来创建空字典的

my_set = {1, 2.3, 'hello', 'python'}

# 创建空集合
aset = set()
print(aset)     # set()
print(type(aset))       # <class 'set'>

# 通过遍历获取数据
for value in my_set:
    print(value)
'''
1
2.3
hello
python
'''

for index, value in enumerate(my_set):
    print(index, value)
'''
0 1
1 2.3
2 hello
3 python
'''

# 添加
my_set.add('11')
my_set.add('hello')
my_set.add('java')
print(my_set)       # {1, 2.3, 'java', 'python', '11', 'hello'}

# 集合可以对容器类型数据进行去重
alist = [1, 1, 3, 5, 6]
new_set = set(alist)       # 把列表转换成集合，可以达到去重的目的
print(new_set)        # {1, 3, 5, 6}

# 列表、元祖、集合三者之间可以进行互相转换

来源：CSDN

作者：qq_Cache陈

链接：https://blog.csdn.net/qq_23904809/article/details/103647959