python基本数据类型使用

一. 字符串函数

1. 字符串的查找检查

   mystr = “hello world itcastPython anditcastCpp”
   index() ：遍历 mystr查找子串，返回找到的第一个子串的起始下标，否则报错
   print(mystr.index(“itcast”))
   print(mystr.index(“haha”))
   print(mystr.index(“itcast”, 13))
   print(mystr.index(“itcast”, 13,28))

   find() ：遍历mystr 查找子串，返回找到的第一个子串的起始下标，否则返回 -1
   print(mystr.find(“itcast”))
   print(mystr.find(“haha”))
   print(mystr.find(“itcast”, 13))
   print(mystr.find(“itcast”, 13,28))

   count(): 遍历mystr 查找子串，返回子串的个数
   print(mystr.count(“itcast”))
   print(mystr.count(“haha”))

   python中str函数isdigit、isdecimal、isnumeric的区别
   num = “1” #unicode
   num.isdigit() # True
   num.isdecimal() # True
   num.isnumeric() # True

   num = “1” # 全角
   num.isdigit() # True
   num.isdecimal() # True
   num.isnumeric() # True

   num = b"1" # byte
   num.isdigit() # True
   num.isdecimal() # AttributeError ‘bytes’ object has no attribute ‘isdecimal’
   num.isnumeric() # AttributeError ‘bytes’ object has no attribute ‘isnumeric’

   num = “IV” # 罗马数字
   num.isdigit() # True
   num.isdecimal() # False
   num.isnumeric() # True

   num = “四” # 汉字
   num.isdigit() # False
   num.isdecimal() # False
   num.isnumeric() # True

   ======================================
   isdigit()
   True: Unicode数字，byte数字（单字节），全角数字（双字节），罗马数字
   False: 汉字数字
   Error: 无

   isdecimal()
   True: Unicode数字，，全角数字（双字节）
   False: 罗马数字，汉字数字
   Error: byte数字（单字节）

   isnumeric()
   True: Unicode数字，全角数字（双字节），罗马数字，汉字数字
   False: 无
   Error: byte数字（单字节）

   str1 = “12345”
   isdigit(): 判断str1是否是整数组成，如果是返回True，否则返回False
   num = input("input a number: ")

   if num.isdigit():
   print(“数字正常”)
   else:
   print(“不合格，必须全部是整数”)
   print(str1.isdigit())

   str2 = “abcdefABCDdwf”
   isalpha()：判断str2是否有纯字母组成，如果是返回True，否则返回False
   print(str2.isalpha())

   isspace(): 判断str3是否由空格组成，如果是返回True，否则返回False
   str3 = " "
   print(str3.isspace())

   startswith(): 判断mystr是否以指定子串起始，如果是返回True，否则返回False
   print(mystr.startswith(“hel”))

   endswith() : 判断mystr 是否以指定子串结尾，如果是返回True, 否则返回False
   print(mystr.endswith(“Cpp”))

2. 字符串的替换与分割

‘’’

Python的数据类型：
可变数据类型：列表， 字典，集合
不可变数据类型： 整型，浮点型，字符串，元组

‘’’

mystr = "  hello world itcastPython and itcastCpp  "
replace(): 替换mystr中指定的子串为另一个字符串，返回替换后的新字符串（先拷贝再修改并返回，原字符串不变）
str1 = mystr.replace("itcast","itheima")
print(mystr.replace("",""))
print(mystr)
print(str1)      



strip(): 去除首尾空格，lstrip() 去除左边的空格， rstrip() 去除右边的空格
print(mystr.strip())



split(): 按指定的分隔符分隔字符串，并返回分隔后的列表（可以很方便的把字符串转为列表，会丢失分隔符）
print(mystr)
print(mystr.strip().split(" "))


lower()： 将mystr的所有字母转换为小写字母
print(mystr.lower())


upper(): 将mystr的所有字母转换为大写字母
print(mystr.upper())



upperswapcase() : 将mystr中所有字母 大小写 互转
print(mystr.swapcase())


capitalize() ： 将mystr的第一个字符大写，其他的全部小写。
print(mystr)
print(mystr.strip().capitalize())



title(): 将mystr的所有单词的首字母大写，其他全部小写
print(mystr.title())


partition(): 将mystr按指定的子串分隔为三部分，子串前为一部分，子串为一部分，子串后为一部分(返回值为一个包含三个元素的元组)
print(mystr)
print(mystr.partition(" and")[1])


center(): 给定一个长度，将mystr居中对齐(长度要大于mystr的字节长度）
print(mystr.center(100))


len(): 查看mystr所占的元素的个数
print(len(mystr))

二. 列表函数

1. 列表数据的增加
   name_list = [“damao”, 20, 18]
   printinsert():向列表指定的下标插入一个数据，原数据和原数据之后的数据默认后移一位
   name_list.insert(2, “ermao”)
   print(name_list)

   append()：在列表某尾追加一个任何类型的数据（区别extend，列表不做拆分）
   name_list.append(“sanmao”)
   name_list.append(16)
   name_list.append([100, 200, 300])
   print(name_list)

   extend()：在列表某尾追加一个数据，如果是列表类型则拆分后，依次将数据追加到列表里
   name_list.extend([“simao”, 14,“wumao”, 12])
   print(name_list)

2. 列表数据的查询
   name_list = [‘damao’, 20, ‘ermao’, 18,‘sanmao’,
   16, [100, 200, 300], ‘simao’, 14, ‘wumao’, 12]
   in / not in ：判断数据是否存在，返回bool值

   如果"ermao" 在列表中，则打印

   if “ermao” in name_list:
   print(“ermao在这，快抓住它！”)

   如果不存在，则追加"ermao"

   else:
   name_list.append(“ermao”)

   index() ： 返回列表里指定元素的下标（如果没有，则报错）
   name = “sanmao”
   if name in name_list: # 如果"sanmao"在列表中，则打印其索引值
   index = name_list.index(“sanmao”)
   print(index)
   else: # 否则提示数据不存在
   print(“数据不存在！”)

   count(): 返回列表里指定元素的个数（如果没有，返回0）
   print(name_list.count(18)) # 返回列表里 18 的个数

3. 列表的修改与删除

   name_list = [‘damao’, 20, ‘ermao’, 18,‘sanmao’,16, [100, 200, 300], ‘simao’, 14, ‘wumao’, 12]
   print(name_list)

   数据的修改: 根据元素下标，直接重新赋值
   name_list[6] = [10, 20, 30]
   print(name_list)

   if [100, 200, 300] in name_list:
   name_list[name_list.index([100, 200, 300])] = “Hello List”
   else:
   print(“数据不存在!”)
   print(name_list)

   数据的删除

   remove() : 删除列表内指定的元素，如果元素不存在则报错
   name_list.remove(“Hello List”)
   print(name_list)

   pop() : 删除列表内指定的下标的数据，并返回该数据（如果没有参数，则默认操作最后的数据）
   name1 = name_list.pop(5)
   print(name1)
   print(name_list)

   name2 = name_list.pop()
   print(name2)
   print(name_list)

   clear()：清空列表所有的数据，但不删除列表
   name_list.clear()
   name_list = []
   print(name_list)

   del (Python提供的删除方式）：可以删除任何数据，或者是列表里的某个下标的元素
   del name_list[0]
   print(name_list)
   del name_list
   print(name_list)

4. 列表的排序的逆置

   sort() : Python 列表提供的方法，在原列表基础上排序，会修改原列表
   Python2 支持混合数据的列表[10, ‘abcd’, 3.14, ‘ABCD’]
   Python3 不支持混合数据的列表

   num_list = [123, 10, 0, -5, 100]
   print(num_list)

   默认 从小到大 排序
   num_list.sort()
   print(num_list)

   参数 reverse = True，表示从大到小 排序（默认 reverse = False)
   num_list.sort(reverse=True)
   print(num_list)

   BIF : sorted(): Python提供的方法，返回排序后的新列表，原列表不变
   str_list = [“aBCD”,“caaa”, ‘Adafew’] # 如果数据是字符串类型，则根据每个字符串的首字母的ASCII码比较

   默认 从小到大 排序
   sortedstr_list1 = sorted(str_list)
   print(sortedstr_list1)
   print(str_list)
   同样的，reverse =True 表示从大到小 排序
   sortedstr_list2 = sorted(str_list,reverse=True)
   print(sortedstr_list2)

   reverse(): 将列表逆置
   print(num_list)
   num_list.reverse()
   print(num_list)

5. 列表的拷贝
   num_list = [10, 20, 30]
   num_list1 = num_list # 浅拷贝：只是增加了一个数据的引用，任何引用修改数据，其他引用也对应修改

   所有引用共享同一个内存的数据

   num_list[1] = 200
   print(num_list)
   print(num_list1)

   copy()：深拷贝，拷贝一份数据给一个新的列表，和原列表没有任何关系
   两个列表不共享内存数据，各自独立
   newnum_list = num_list.copy()
   print(num_list)
   print(newnum_list)

6. 列表的推导式
   比较 Pythonic 的列表处理
   生成一个 1 ~ 21 之间所有偶数的列表

   直接创建列表
   num_list1 = [2, 4, 6, 8, 10, 12, 14, 16,18, 20]
   print(num_list1)

   利用range() 函数生成等差数列
   num_list2 = list(range(2, 21, 2))
   print(num_list2)

   while 循环

   num_list3 = []
   i = 2
   while i <= 20:
   if i % 2 == 0:
   num_list3.append(i)
   i+= 1
   print(num_list3)

   for 迭代 + range()

   num_list4 = []
   for i in range(1, 21):
   if i % 2 == 0:
   num_list4.append(i)
   print(num_list4)

   列表推导式（列表生成式） : 创建列表 / 处理列表数据

   num_list5 = [i for i in range(1, 21) if i %2 == 0]

   “”"

   for i in range(1, 21):
   if i % 2 == 0:
   num_list4.append(i)
   “”"
   print(num_list5)

   生成一个 1 ~ 21 之间所有偶数的平方的列表

   num_list6 = [i ** 2 for i in range(1, 21)if i % 2 == 0]
   print(num_list6)

   生成 10 个 “666” 的列表

   num_list7 = [“666” for _ inrange(10)]
   print(num_list7)

   [‘damao’, 10, ‘ermao’, 20] 获取列表里长度大于3的字符串
   lis = [‘damao’, 10, ‘ermao’, 20]
   num_list8 = [i for i in lis if len(str(i))> 3]
   print(num_list8)

   [i for i in range(10) i = 10] 错误，for in 后面只能跟 if
   [x for x in list if True]

   a = [lambda: x for x in range(1, 10) ]
   print(a)
   print(a0)

7. 列表的使用技巧

   列表的合并

   list1 = [10, 20, 30]
   list2 = [‘a’, ‘b’, ‘c’]
   list3 = list1 + list2 # list2 的数据在 list1 后面追加，并生成了一个新列表
   print(list3)
   print(‘list1的id:%s, list3的id: %s’ % (id(list1), id(list3)))

   等同 extend() ： list1.extend(list2)
   list1 += list2 # list2 的数据在list1 后面追加，但是不会生成新列表，数据全部在list1里面
   print(id(list1))

   " ".join() 将列表转换为字符串

   字符串转列表：

   mystr = “hello world hellopython!”
   str_list = mystr.split(" ") # 按分隔符转换为列表
   print(str_list)
   print(list(mystr)) # list(str) 将字符串每个字符当成列表的一个元素，转换为列表

   列表转字符串：
   print(str_list)
   print("".join(str_list)) # " ".join() 默认只能将全是字符串的列表 转成字符串

   num_list = [10, 20, 30]
   print(" ".join(num_list)) # 报错：非字符串部分不能转换

   其他数据类型的列表 转 字符串

   [num_list = 10.10, 20,30, “string”] # 其他数据类型的列表
   print(num_list)

   print(" ".join([str(num) for numin num_list])) # 通过列表推导式，将每个元素通过str()处理后再转换

   numstr_list = [str(i) for i in num_list]
   num_str = " ".join(numstr_list)
   print(num_str)

   BIF 类型判断：isinstance()： 可以判断对象是否是指定的类型，如果是则返回True，否则返回False

   printpassword = input(“请输入密码:”)
   if isinstance(password, str):
   print(“password 是字符串”)
   elif isinstance(password, int):
   print(“password 是整型…”)
   else:
   print(type(password))

​

num_list = [12, 34, [100, 200, 300], 56,78, [400, 500, 600]]
for num in num_list:
   if isinstance(num, list):  # 判断num 是否是一个列表，如果是，则继续迭代取值
       for i in num:
           print(i)
   else:  # 否则直接打印
       print(num)



BIF : enumerate(list, tuple ....): 返回一个列表，包含了原列表的元素下标 和 元素 的元组。

num_list2 = [10, 20, 30, 40, 50, 60]
enumerate() 枚举，可以让我们通过元素下标来处理数据 (拆包）
enumerate(num_list2) == [(0, 10), (1, 20),(2, 30), (5, 60)]
for index, value in enumerate(num_list2):
   if index % 2 == 0:
       print(index, value)


for i in enumerate(num_list2):
print(i)

三. 元组的查询统计

tuple()

1. 通过range() 创建

   t1 = tuple(range(10, 20, 2))
   print(t1)

2. 直接创建元组

   t2 = (20, 30, 40, 50)
   print(t2)

   t3 = (100, ) # 只有一个元素的时候，要加 ,
   print(t3)
   print(type(t3))

3. 并没有元组推导式，但是会返回一个可迭代对象

   t4 = (i for i in range(20) if i % 2 == 0)
   for i in t4:
   print(i)

   t5 = (100, 200, 300, 200, 100, [10, 20, 30], ‘hello Python’)

   index(): 返回指定元素的 下标值（如果没有，则报错）

   num = t5.index(“hello Python”)
   print(num)

4. 元组的修改：元组本身元素不可修改

   t5[6] = “Hello World!”
   print(t5)

   num_list = t5[5]
   num_list[1]

   元组的元素不可变（元组的某个元素如果可变，那么也可以修改数据）
   不代表元组的元素不可变。
   t55 = 200
   print(t5)

   count() : 返回指定元素的个数,如果没有则返回0
   print(t5.count(200))

四. 字典（dictionary）

1. 字典的获取删除

   字典数据的添加

   根据键名添加或修改
   name_dict = {}
   print(name_dict)

   name_dict[‘name’] = “python” # 如果字典没有这个键，则创建这个键值对
   print(name_dict)

   name_dict[‘name’] = “hello” # 如果字典有这个键，则重新赋值
   print(name_dict)

   setdefault() :
   print(name_dict.setdefault(“name”)) # 如果有这个键，则返回这个键对应的值
   print(name_dict.setdefault(“age”)) # 如果没有这个键，则返回 None，同时创建这个键值对，默认值是None
   print(name_dict.setdefault(“id”,110)) # 如果没有这个键，则创建这个键和指定值的 键值对，并返回指定的值
   print(name_dict)

   keys() : 返回这个字典的所有的键 的列表(返回类型为:class’dict_keys’,需通过list()转换)
   print(list(name_dict.keys()))
   print(name_dict[‘test’])
   if “test” in name_dict.keys():
   print(“name存在 %s” %name_dict[“test”])
   else:
   print(“test 未找到”)

   values()： 返回这个字典的所有的值 的列表()(返回类型为:class ‘dict_values’,需通过list()转换)
   print(name_dict.values())
   for value in name_dict.values():
   print(value)

   items()： 返回这个字典的所有的 键值对（元组） 的列表(返回类型为:class’items’,需通过list()转换)
   print(list(name_dict.items()))
   for key, value in name_dict.items():

   print(key, value)
   

   get() 返回指定键的值，如果没有这个键，默认返回None，如果指定第二个参数，则返回参数值
   print(name_dict)
   print(name_dict.get(“name”))
   print(name_dict.get(“test”))
   print(name_dict.get(“test”,False)) # get() 不会创建键值对，setdefault() 会创建

   name_dict.setdefault(“name”) # 如果有这个键，则返回键对应的值，否则创建键值对，默认值为None
   name_dict.setdefault(“test”,1234) # 如果指定了第二个参数，则创建键值对的值为 参数值
   print(name_dict[“name”]) # 如果有这个键，返回值；如果没有，则报错

   if name_dict.get(“test”):
   print(name_dict[“test”])
   else:
   print(“test 不存在！”)

   update : 更新info_dict 的内容，参数是一个dict类型。
   不仅覆盖已有的数据,还能新增没有的数据
   info_dict = {“name”:“python”, “age”: 26, “id”: 110, 0:“number”}
   newinfo_dict = {“name”:“hello”, “id”: 119}
   print(newinfo_dict)
   newinfo_dict.update(info_dict)
   print(newinfo_dict)

2. 字典的拷贝

   name_dict = {“name”:“python”, “age”: 26, “id”: 110, 0:“number”}
   copy(): 深拷贝字典，创建一个新的字典对象，而非引用
   import copy
   newname_dict =copy.deepcopy(name_dict) # 内存层深拷贝，拷贝全新的数据
   newname_dict = name_dict.copy() # 创建一个新字典，而非引用

3. 字典的删除

   pop() : 参数是键，删除指定的键值对，并返回值 （第二个参数表示如果没有这个键，则返回这个参数值）
   name = newname_dict.pop(“name”) # “name” 键存在，返回"name"对应的值
   print(name)
   print(newname_dict)
   name =newname_dict.pop(“newname”, “hello”) # “newname” 不存在，返回 “hello”
   print(name)
   print(newname_dict)

   popitem() : 依次 从后向前 删除键值对，并返回这个键值对的元组
   key, value = newname_dict.popitem() # 拆包（拆分元组，并用变量接收）
   print(key)
   print(value)

   key_list = []
   value_list = []
   for i in range(len(newname_dict)):
   key, value = newname_dict.popitem()
   key_list.append(key)
   value_list.append(value)
   print(key_list)
   print(value_list)
   print(newname_dict)
   newname_dict.popitem()

   clear() : 清空字典的数据，但不删除字典
   newname_dict.clear()
   print(newname_dict)

   del() / del
   del(newname_dict)
   print(“hahah”)
   print(newname_dict)
   print(name_dict)

4. 字典推导式

   列表推导式
   num_list = [i for i in range(1, 21)] # 返回数据时，不需要处理为键值对
   print(num_list)

   字典推导式
   num_dict = {i: i ** 2 for i in range(1,21)} # 返回数据时，处理键值对结果
   print(num_dict)

   将两个列表的元素 合并为一个 字典
   key_list = [“name”,“age”, “id”]
   value_list = [“python”, 18, 110]
   name_dict = {key_list[i]: value_list[i] fori in range(len(key_list))}
   print(name_dict)

   将字典转换为 两个列表，分别存储 key和value
   key_list1 = []
   value_list1 = []
   for key, value in name_dict.items():
   key_list1.append(key)
   value_list1.append(value)
   print(key_list1)
   print(value_list1)

   字典的键值对 互相转换
   print(name_dict)
   newname_dict = {value: key for key, valuein name_dict.items()}
   print(newname_dict)

五. 集合的使用

集合 、 列表、 元组 可以互相转换
集合里的数据都是唯一的，没有重复的数据

1. 创建集合

   num_dict = {} # 创建空字典
   num_set = set() # 创建空集合

   print(type(num_set))
   set(list) 最常用的集合处理，把列表转成集合
   set.add() : 向集合里添加一个数据
   num_list = [10, 23, 43, 23, 10, 0, -10, 0]
   print(list(set(num_list))) # 将列表快速去重
   num_set = {10, 20, 30,20, 30, 10, 100}
   print(num_set)

   print字典和集合都是无序的，1. 不支持下标索引， 2.不支持排序
   print(sorted(num_set)) # 先转成了列表，再排序，所以排序结果是一个列表

2. 添加数据：

   add() : 向集合里添加一个数据
   num_set.add(200)
   print(num_set)
   print(num_set[2])

   update() ：向集合里添加多个数据（参数是一个列表，把列表里的每个元素添加到集合里）
   num_set.update([500, 600, 700])
   print(num_set)

3. 删除数据：

   remove(): 删除指定的数据，remove 删除指定数据，数据不存在则报错
   num_set.remove(600)
   print(num_set)

   discard() : 删除指定的数据，如果数据不存在，则不会做任何操作
   print(“nothing”)
   num_set.discard(6000)
   print(num_set)

   pop() : 删除指定数据（默认从头部开始删除并返回），并返回该数据
   num = num_set.pop()
   print(num)
   print(num_set)

   如果有需要，一般集合都会转成列表做复杂操作，然后再转回集合

4. 集合推导式 （ Python里的三个推导式：列表推导式、字典推导式、集合推导式）

   set1 = {i for i in range(1, 5, 1)}
   set2 = {i for i in range(2, 6, 1)}
   print(set1)
   print(set2)

5. 交集 ： 两个集合 共有的部分

   print(set1 & set2)

6. 并集 : 合并两个集合，并去重

   print(set1 | set2)

7. 差集 :

   print(set1 - set2) # set1 有的但是set2 没有的
   print(set2 - set1) # set2 有的但是set1 没有的