python基础003

基本数据类型的使用

• 一.字符串类型的使用
• 二.元祖类型的使用
• 三.列表类型的使用
• 四.字典类型的使用
• 四.可迭代对象和不可迭代对象

一.字符串类型的使用

# 字符串的使用
# count() 返回字符串中指定成员的数量 star：开始位置索引 end：结束位置索引
char_001 = "abcdacc abcddacc adcdacc"
print(char_001.count("ab"), end="\t")
print(char_001.count('ab', 5, len(char_001) - 1), end="\t")
print(char_001.count('ab', 0, -1), end="\t")
print(char_001.count('ab', -17, -1), end="\t")
print(char_001.count('ab', 5, -1), end="\t")
print(char_001.count('ab', 5, -16), end="\t")
print(char_001.count('ab', 2), end="\n")

# index() 返回指定字符串索引
print(char_001.index("ab"), end="\t")
# print(char_001.index("aba"))  # 没有找到会报错
print(char_001.index("ab", 6, 10), end="\n")

# upper() 将字符传转换为大写
print(char_001.upper())

# lower() 将字符传转换为小写
print(char_001.upper().lower())

# title() 将每个单词的首字母转化为大写
print(char_001.title())

# startswith() 是否以指定的子字符串开始
print(char_001.startswith("a"), end="\t")
print(char_001.startswith("b"), end="\n")

# enswith() 是否以指定的子字符串结束
print(char_001.endswith("c"), end="\t")
print(char_001.endswith("b"), end="\n")

# replace() 将指定字符串替换成新的字符串
print(char_001.replace("a", "b"))
print(char_001.replace("a", "b", 3))
print(char_001.replace("ab", "bc", 1))

# strip() 将字符串前后的空字符 包括空格 \t \n
char_002 = " \n\tabcdacc abcddacc adcdacc\n "
print(char_002.strip())

# split([char]) 将字符串使用指定字符分割（不指定则默认空格分割），然后返回一个列表
print(char_002.split())
print(char_001.split("ab"))
print(char_002.split("b"))

# join(iterable)  将可迭代对象转成字符串 (字符串，元祖，字典，集合，列表)
print("".join("abc"))
print(",".join("abc"))
print(",".join(['a', 'b', 'c']))
print(":".join({'a', 'b', 'c'}))
print(";".join(('a', 'b', 'c')))
print("?".join({"a": 1, "b": 2}))

# rjust() 用指定符号补齐字符串长度
print("abc".rjust(10, "*"))

# ljust() 用指定符号补齐字符串长度
print("abc".ljust(10, "*"))

# isupper()  检查字符串是否全部为大写
print(char_001.upper().isupper(), end="\t")
print(char_001.isupper(), end="\n")

# islower() 检查字符串是否全部为小写
print(char_001.islower(), end="\t")
print(char_001.upper().islower(), end="\n")

# isalnum() 检查字符串是否由子母或者数字组成
print(char_001.isalnum(), end="\t")
print("123abc".isalnum(), end="\t")
print("abc".isalnum(), end="\t")
print("123".isalnum(), end="\t")
print("123就是就是减肥".isalnum(), end="\n")

# isalpha() 检查字符串是否由子母组成
print("123".isalpha(), end="\t")
print("1是的是的23".isalpha(), end="\t")
print("12ASSaaaa3".isalpha(), end="\t")
print("ASSaaaa".isalpha(), end="\n")

# isdecimal() 检查字符串是否由数字组成 isdigit isnumeric
print("123".isdecimal(), end="\t")
print("1是的是的23".isdecimal(), end="\t")
print("12ASSaaaa3".isdecimal(), end="\t")
print("ASSaaaa".isdecimal(), end="\n")

print("123".isdigit(), end="\t")
print("1是的是的23".isdigit(), end="\t")
print("12ASSaaaa3".isdigit(), end="\t")
print("ASSaaaa".isdigit(), end="\n")

print("123".isnumeric(), end="\t")
print("1是的是的23".isnumeric(), end="\t")
print("12ASSaaaa3".isnumeric(), end="\t")
print("ASSaaaa".isnumeric(), end="\n")

# encode() 对字符串进行编码
print("qwe".encode("utf8"), end="\t")
print("qwe".encode("gbk"))

# decode() 对字符串进行解码
print("qwe".encode('utf8').decode("utf8"), end="\t")
print("qwe".encode("gbk").decode("gbk"))

# center() 居中
print("欢迎光临".center(50, "*"))

# 输出
2	1	2	1	1	0	1
0	8
ABCDACC ABCDDACC ADCDACC
abcdacc abcddacc adcdacc
Abcdacc Abcddacc Adcdacc
True	False
True	False
bbcdbcc bbcddbcc bdcdbcc
bbcdbcc bbcddacc adcdacc
bccdacc abcddacc adcdacc
abcdacc abcddacc adcdacc
['abcdacc', 'abcddacc', 'adcdacc']
['', 'cdacc ', 'cddacc adcdacc']
[' \n\ta', 'cdacc a', 'cddacc adcdacc\n ']
abc
a,b,c
a,b,c
a:c:b
a;b;c
a?b
*******abc
abc*******
True	False
True	False
False	True	True	True	True
False	False	False	True
True	False	False	False
True	False	False	False
True	False	False	False
b'qwe'	b'qwe'
qwe	qwe
***********************欢迎光临***********************

二.元祖类型的使用

# tuple 元祖方法

# index() 返回元素在元祖中的索引 如果不存在 则报错 元祖的star和end 为 左闭右开
tuple001 = (1, 2, 3, 'a', "bc", 'a', 1)
print(tuple001.index("a"), end='\t')
print(tuple001.index(1, 4, 7), end='\t')
print(tuple001[6], end='\n')

# count() 返回元素在元祖中的数量 如果不存在 则返回0
print(tuple001.count("a"))

# 输出
3	6	1
2

三.列表类型的使用

# 列表方法

# index() 返回元素在列表中的索引 如果不存在 则报错 列表的star和end 为 左闭右开
list_001 = [1, 2, 3, "a", "b", "a"]
print(list_001.index("a"), end="\t")
print(list_001.index("a", 4, 7))

# count() 返回元素在列表中的数量 如果不存在 则返回0
print(list_001.count("a"))

# clear() 清空列表
list_001.clear()
print(list_001, end='\n\n')

# remove() 删除列表中指定元素 存在多个 删除索引最小 不存在 报错
list_002 = [1, 2, 3, "a", "b", "a"]
list_002.remove("a")
print(list_002, end='\n\n')

# pop() 删除列表元素 根据索引删除元素 不指定索引则删除最后一个元素
list_003 = [1, 2, 3, "a", "b", "a"]
list_003.pop()
print(list_003)
list_003.pop(3)
print(list_003)
list_003.pop(-2)
print(list_003, end='\n\n')

# append() 在列表末尾添加元素 可以是任意数据类型
list_004 = [1, 2, 3, "a", "b", "a"]
list_004.append([1, 2, 3])
print(list_004)
list_004.append((1, 2, 3))
print(list_004)
list_004.append({1, 2, 3})
print(list_004)
list_004.append({"a": 1, "b": 2})
print(list_004)
list_004.append("1243dfg")
print(list_004)
list_004.append(1.23)
print(list_004)
list_004.append(123)
print(list_004, end='\n\n')

# insert() 在列表的指定索引处插入一个元素
list_005 = [1, 2, 3, "a", "b", "a"]
list_005.insert(4, {"a": 1, "b": 2})
print(list_005)

# extend() 将一个可迭代对象的元素分别添加的列表
list_006 = [1, 2, 3, "a", "b", "a"]
list_006.extend("abchf")
print(list_006)
list_006.extend({1, 2, 3, 4})
print(list_006)
list_006.extend({"a": 1, "b": 2})
print(list_006)
list_006.extend((1, 2, 3, 4))
print(list_006)
list_006.extend([1, 2, 3, 4])
print(list_006, end='\n\n')

# sort([reverse]) 排序 默认升序
list_007 = [5, 2, 1, 4, 6, 3]
list_007.sort()
print(list_007)
list_007.sort(reverse=True)
print(list_007, end='\n\n')

# reverse() 将列表反向
list_008 = [1, 2, 3, "a", "b", "a"]
list_008.reverse()
print(list_008, end='\n\n')

# copy() 拷贝 浅拷贝
list_009 = [1, 2, 3, "a", "b", "a"]
list_010 = list_009.copy()
print(list_010)
print(list_010 == list_009)
print(list_010 is list_009)
list_009.append("c")
print(list_010)
print(list_009)

# 输出
3	5
2
[]

[1, 2, 3, 'b', 'a']

[1, 2, 3, 'a', 'b']
[1, 2, 3, 'b']
[1, 2, 'b']

[1, 2, 3, 'a', 'b', 'a', [1, 2, 3]]
[1, 2, 3, 'a', 'b', 'a', [1, 2, 3], (1, 2, 3)]
[1, 2, 3, 'a', 'b', 'a', [1, 2, 3], (1, 2, 3), {1, 2, 3}]
[1, 2, 3, 'a', 'b', 'a', [1, 2, 3], (1, 2, 3), {1, 2, 3}, {'a': 1, 'b': 2}]
[1, 2, 3, 'a', 'b', 'a', [1, 2, 3], (1, 2, 3), {1, 2, 3}, {'a': 1, 'b': 2}, '1243dfg']
[1, 2, 3, 'a', 'b', 'a', [1, 2, 3], (1, 2, 3), {1, 2, 3}, {'a': 1, 'b': 2}, '1243dfg', 1.23]
[1, 2, 3, 'a', 'b', 'a', [1, 2, 3], (1, 2, 3), {1, 2, 3}, {'a': 1, 'b': 2}, '1243dfg', 1.23, 123]

[1, 2, 3, 'a', {'a': 1, 'b': 2}, 'b', 'a']
[1, 2, 3, 'a', 'b', 'a', 'a', 'b', 'c', 'h', 'f']
[1, 2, 3, 'a', 'b', 'a', 'a', 'b', 'c', 'h', 'f', 1, 2, 3, 4]
[1, 2, 3, 'a', 'b', 'a', 'a', 'b', 'c', 'h', 'f', 1, 2, 3, 4, 'a', 'b']
[1, 2, 3, 'a', 'b', 'a', 'a', 'b', 'c', 'h', 'f', 1, 2, 3, 4, 'a', 'b', 1, 2, 3, 4]
[1, 2, 3, 'a', 'b', 'a', 'a', 'b', 'c', 'h', 'f', 1, 2, 3, 4, 'a', 'b', 1, 2, 3, 4, 1, 2, 3, 4]

[1, 2, 3, 4, 5, 6]
[6, 5, 4, 3, 2, 1]

['a', 'b', 'a', 3, 2, 1]

[1, 2, 3, 'a', 'b', 'a']
True
False
[1, 2, 3, 'a', 'b', 'a']
[1, 2, 3, 'a', 'b', 'a', 'c']

四.字典类型的使用

# 字典方法

# pop() 删除指定的键
dict_001 = {"a": 1, "b": 2}
dict_001.pop("b")
print(dict_001, end='\n\n')

# get() 获取指定的键的值 没有时返回none
dict_002 = {"a": 1, "b": 2}
print(dict_001.get("a"))
print(dict_001.get("ab"), end='\n\n')

# values() 用户返回字典中所有的值
dict_003 = {"a": 1, "b": 2}
print(dict_003.values())
print(type(dict_003.values()))
print(2 in dict_003.values())
print(3 in dict_003.values(), end='\n\n')

# keys() 以dict_keys格式返回字典中所有的键
dict_004 = {"a": 1, "b": 2}
print(dict_004.keys())
print(type(dict_004.keys()))
print("a" in dict_004.keys(), end='\n\n')

# update() 将字典对象更新至字典中
dict_005 = {"a": 1, "b": 2}
dict_005.update(c=3)
print(dict_005)
dict_005.update({"a": 1, "aa": 2})
print(dict_005, end='\n\n')

# setdefault(key，default_value) 返回指定键的值，不存在则新增，并且返回default_value；存在，则返回对应的值
dict_006 = {"a": 1, "b": 2}
print(dict_006.setdefault("a", 2))
print(dict_006.setdefault("a"))
print(dict_006.setdefault("d", 4), end="\n\n")

# items() 以dict_items格式返回字典中键值对 并保存在元祖中
print(dict_006.items(), end="\n\n")

# popitem() 移除键值对
dict_007 = {"a": 1, "b": 2, "c": 2, "d": 2}
dict_007.popitem()
print(dict_007, end="\n\n")

# fromkeys() 从可迭代对象创建一个字典 value为 None
dict_008 = {"a": 1, "b": 2, "c": 2, "d": 2}
print(dict_008.fromkeys("abcdefaaaag"))
print(dict_008.fromkeys(["a", "b", "c", "d", "e"]))
print(dict_008.fromkeys((1, 2, 3, 45, 6, 7)))
print(dict_008.fromkeys({1, 2, 3, 4, 4, 5, 5, }))
print(dict_008.fromkeys({"a": 1, "b": 2, "c": 2, "d": 2}))

# 输出
{'a': 1}

1
None

dict_values([1, 2])
<class 'dict_values'>
True
False

dict_keys(['a', 'b'])
<class 'dict_keys'>
True

{'a': 1, 'b': 2, 'c': 3}
{'a': 1, 'b': 2, 'c': 3, 'aa': 2}

1
1
4

dict_items([('a', 1), ('b', 2), ('d', 4)])

{'a': 1, 'b': 2, 'c': 2}

{'a': None, 'b': None, 'c': None, 'd': None, 'e': None, 'f': None, 'g': None}
{'a': None, 'b': None, 'c': None, 'd': None, 'e': None}
{1: None, 2: None, 3: None, 45: None, 6: None, 7: None}
{1: None, 2: None, 3: None, 4: None, 5: None}
{'a': None, 'b': None, 'c': None, 'd': None}

四.可迭代对象和不可迭代对象

# 可迭代对象
# 内部包含__iter__()方法的对象 支持循环遍历
# 字符串，列表，元祖，集合，字典
"".__iter__()
[].__iter__()
().__iter__()
{"a": 1}.__iter__()
{1, 2, 3}.__iter__()

# 可迭代对象分为两类 ：
# 序列：字符串，元祖，列表   *** 作类型：索引（通过索引访问序列中的元素 [9,len()-1]) 和 切片

# 索引 *** 作
s = "abctjdjk"  # 值不可变
t = (1, 2, 3, 4, 5)  # 值不可变
l = [1, 2, 3, 4, 5, 6]  # 值可变
print(s[1], t[2], l[3])
l[3] = "a"
print(s[1], t[2], l[3], end="\n\n")

# 切片
# 用过索引返回对象的子元素片段
# 语法："obj[start:end:step]"
# star 开始位置，如果省略则从第一个开始
# end 表示结束位置， 实际返回的是end-1 位置上的元素 如果省略表示取到最后一个元素
# step 步长 每间隔多少元素取一个 如果省略 表示 1

print(s[0:-1])  # 从第一个元素，取到倒数第二个元素
print(t[0:-1])
print(l[0:-1])

print(s[:])

l1 = l[:]
l2 = l
print(l1 == l2)
print(l2 is l2)

print(l[::-1])  # 类似于 reverse()
print(l[1:6:-1])
print(l[1:-2:2])

print(t[::-1])
print(t[1:3:-1])

# 非序列：集合，字典
dic = {"a": 1, "b": 2}
print(dic["a"])  # 访问键值对
dic["a"] = "aa"  # 为指定键值对重新赋值
print(dic)
dic["d"] = 123  # 不存在则新增键值对
print(dic)

# 输出
b 3 4
b 3 a

abctjdj
(1, 2, 3, 4)
[1, 2, 3, 'a', 5]
abctjdjk
True
True
[6, 5, 'a', 3, 2, 1]
[]
[2, 'a']
(5, 4, 3, 2, 1)
()
1
{'a': 'aa', 'b': 2}
{'a': 'aa', 'b': 2, 'd': 123}