首页 > 其他分享 >day03

day03

时间：2023-07-17 19:55:44浏览次数：40  
标签：name pythoners day03 list dic nick print

数字类型内置方法

整型内置方法（int）

  • 用途：年龄、号码、等级

  • 定义：可以使用int()方法将纯数字的字符串转为十进制的整型

age = 19  # age = int(19)
print(type(age))

<class 'int'>

x = int('111')
print(type(x))

<class 'int'>

x = int('11.1')  # 报错
print(x)

长整型

长整型只在python2中存在，python3中不存在长整型。

x = 11111111111111111111111111111111111111111111111
print(type(x))  # longint

可变或不可变数据类型

age = 19
print(f'first:{id(age)}')
age = 20
print(f'second:{id(age)}')

first:1906602016
second:1906602048

浮点型内置方法（float）

  • 用途：薪资、身高、体重

  • 定义：可以使用float()方法将纯数字的字符串转为浮点型数字。

age = 3.1  # age = float(3.1)
print(type(age))

<class 'float'>

x = float('111')
print(x)
print(type(x))

111.0
<class 'float'>

x = float('11.1')  
print(type(x))

<class 'float'>

salary = 3.1
print(f'first:{id(salary)}')
salary = 5.1
print(f'second:{id(salary)}')

first:2301328060016
second:2301328059776

字符串类型内置方法（str）

1.用途：描述性质的东西，如人的名字、单个爱好、地址、国家等

2.定义：使用''、""、''''''、""""""包裹的的一串字符

* u'unicode': unicode编码的字符串
* b'101': 二进制编码的字符串
* r'\n': 原生字符串，也就是说'\n'这是普通的两个字符，并没有换行的意思

name = 'nick'  # name =str('nick')
s1 = str(1.1)
s2 = str([1, 2, 3])

print(f's1:{s1}, type:{type(s1)}')
print(f's2:{s2}, type:{type(s2)}')

s1:1.1, type:<class 'str'>
s2:[1, 2, 3], type:<class 'str'>

必须掌握

  • 按索引取值
  • 切片
  • 长度len
  • 成员运算in|not in
  • 移除空白strip
  • 切分split
  • 循环

1.按索引取值（只可取不可改变）

# str索引取值
msg = 'hello nick'
#      0123456789  # 索引序号

print(f'索引为6: {msg[6]}')
print(f'索引为-3: {msg[-3]}')

索引为6: n
索引为-3: i

2.切片（顾头不顾尾，步长）

# 索引切片
msg = 'hello nick'
#      0123456789  # 索引序号

print(f'切片3-最后: {msg[3:]}')
print(f'切片3-8: {msg[3:8]}')
print(f'切片3-8，步长为2: {msg[3:8:2]}')
print(f'切片3-最后，步长为2: {msg[3::2]}')

# 了解，步长为正从左到右；步长为负从右到左
print('\n**了解知识点**')
print(f'切片所有: {msg[:]}')
print(f'反转所有: {msg[::-1]}')
print(f'切片-5--2: {msg[-5:-2:1]}')
print(f'切片-2--5: {msg[-2:-5:-1]}')

切片3-最后: lo nick
切片3-8: lo ni
切片3-8，步长为2: l i
切片3-最后，步长为2: l ik

**了解知识点**
切片所有: hello nick
反转所有: kcin olleh
切片-5--2:  ni
切片-2--5: cin

3.长度len

# str长度
msg = 'hello nick'

print(len(msg))

10

4.成员运算in和not in

# str成员运算
msg = 'my name is nick, nick handsome'

print(f"'nick' in msg: {'nick' in msg}")
print(f"'jason' not in msg: {'jason' not in msg}")
print(f"not 'jason' in msg: {not 'jason' in msg}")

'nick' in msg: True
'jason' not in msg: True
not 'jason' in msg: True

5.移除空白strip()

# str移除空白strip()
name = '&&&n ick'

print(f"name.strip('&'): {name.strip('&')}")  # strip()默认为‘ ’，并且不修改原值，新创建空间
print(f"name: {name}")

# strip()应用场景
pwd = input('password: ')  # 用户可能会手抖输入空格
if pwd.strip() == '123':
    print('密码输入成功')

print(f"'*-&nick+'.strip('*-& +'): {{'*-&nick+'.strip('*-& +')}}")

name.strip('&'): n ick
name: &&&n ick
password: 123
密码输入成功
'*-& nick+'.strip('*-& +'): nick

strip() 方法用于移除字符串开头和结尾的空白字符（默认为空格），并返回一个新的字符串。它对于处理用户输入时特别有用，可以去除不必要的空格，例如用户在输入时可能会不小心输入额外的空格。
strip() 方法不会修改原始字符串本身，而是返回一个新的字符串。如果你想要修改原始字符串，你可以将新的结果赋值给原始变量，例如 message = message.strip()。

# 举例
message = "  Hello, World!   "

print(f"Original message: '{message}'")
print(f"Stripped message: '{message.strip()}'")

Original message: '  Hello, World!   '
Stripped message: 'Hello, World!'

6.切分split

# str切分split
info = 'nick:male:19'
info_list1 = info.split(':')
info_list2 = info.split(':', 1)

print(f'info_list1:{info_list1}')
print(f'info_list2:{info_list2}')

info_list1:['nick', 'male', '19']
info_list2:['nick', 'male:19']

7.循环

msg = 'hello nick'

for i in msg:
    print(i)
    

h
e
l
l
o
 
n
i
c
k

需要掌握

  • lstrip&rstrip
  • lower&upper
  • startswith&endswith
  • rsplit
  • join
  • replace
  • isdigit

1.lstrip()和rstrip()

# str之lstrip()和rstrip()
name = '&&nick&&'

print(f"nick.lstrip('&'): {name.lstrip('&')}")
print(f"nick.rstrip('&'): {name.rstrip('&')}")

nick.lstrip('&'): nick&&
nick.rstrip('&'): &&nick

2.lower()和upper()

# str之lower()和upper()
name = 'Nick Chen'

print(f"name.upper(): {name.lower()}")
print(f"name.upper(): {name.upper()}")

name.upper(): nick chen
name.upper(): NICK CHEN

3.startswith()和endswith()

# str之startswith()和endswith()
name = 'Nick Chen'

print(f"name.startswith('Nick'): {name.startswith('Nick')}")
print(f"name.endswith('chen'): {name.endswith('chen')}")

name.startswith('Nick'): True
name.endswith('chen'): False

4.rsplit()

# str之rsplit()
info = 'nick:male:19'

print(f"info.rsplit(':', 1): {info.rsplit(':', 1)}")  # 从右开始切割

info.rsplit(':', 1): ['nick:male', '19']

#rsplit() 方法用于将字符串从右侧进行拆分，并返回一个包含拆分结果的列表。它可以根据指定的分隔符将字符串拆分成多个子字符串。
string.rsplit(sep=None, maxsplit=-1)
  • sep（可选）是用于指定分隔符的字符串。如果未提供此参数，rsplit() 方法将默认使用空白字符（空格、制表符、换行符等）作为分隔符。
  • maxsplit（可选）是用于指定最大拆分次数的整数。如果未指定或为负数，则表示没有拆分限制。
message = "Welcome to the world of Python programming"

# 使用默认分隔符（空白字符）进行拆分
print(message.rsplit())  # 输出: ['Welcome', 'to', 'the', 'world', 'of', 'Python', 'programming']

# 使用逗号作为分隔符进行拆分
print(message.rsplit(", "))  # 输出: ['Welcome to the world of Python programming']

# 指定最大拆分次数为2
print(message.rsplit(maxsplit=2))  # 输出: ['Welcome to the world', 'of', 'Python programming']

['Welcome', 'to', 'the', 'world', 'of', 'Python', 'programming']
['Welcome to the world of Python programming']
['Welcome to the world of', 'Python', 'programming']

5.join()

lis = [1,2,'19']
print(f"':'.join(lis): {':'.join(lis)}")  # 报错，数字不可和字符串拼接

# str之join()
lis = ['nick', 'male', '19']

print(f"':'.join(lis): {':'.join(lis)}")

':'.join(lis): nick:male:19

6.replace()

# str值replace()
name = 'nick shuai'

print(f"name.replace('shuai','handsome'): {name.replace('shuai','handsome')}")

name.replace('shuai','handsome'): nick handsome

7.isdigit()

# str值isdigit()
salary = '111'
print(salary.isdigit())  # True

salary = '111.1'
print(salary.isdigit())  # False

True
False

isdigit() 方法可以用于判断一个字符串是否只包含数字字符。如果是数字字符，返回值为 True，否则返回 False。需要注意的是，字符串中不能包含任何其他非数字字符，包括空格、符号或小数点等。

# str之isdigit()应用场景
age = input('age: ')
if age.isdigit():
    age = int(age)

    if age < 18:
        print('小姐姐')
    else:
        print('阿姨好')
else:
    print(f'你的年龄能是这个{age}?')

age: 逗你
你的年龄能是这个逗你?

其他

  • find|rfind|index|rindex|count
  • center|ljust|rjust|zfill
  • expandtabs
  • captalize|swapcase|title
  • is系列

find()、rfind()、index()、rindex()、count()

# find(substring)：返回子字符串 substring 在原字符串中第一次出现的索引位置。如果未找到子字符串，则返回 -1。
message = "Hello, World!"
index = message.find("World")
print(index)  # 输出: 7

7

# rfind(substring)：返回子字符串 substring 在原字符串中最后一次出现的索引位置。如果未找到子字符串，则返回 -1。
message = "Hello, World!"
index = message.rfind("o")
print(index)  # 输出: 8

8

# index(substring)：与 find() 方法类似，返回子字符串 substring 在原字符串中第一次出现的索引位置。如果未找到子字符串，会抛出 ValueError 异常。
message = "Hello, World!"
index = message.index("World")
print(index)  # 输出: 7

7

# rindex(substring)：与 rfind() 方法类似，返回子字符串 substring 在原字符串中最后一次出现的索引位置。如果未找到子字符串，会抛出 ValueError 异常。
message = "Hello, World!"
index = message.rindex("o")
print(index)  # 输出: 8

8

# count(substring)：返回子字符串 substring 在原字符串中出现的次数
message = "Hello, World!"
count = message.count("l")
print(count)  # 输出: 3

3

center()、ljust()、rjust()、zfill()

# center(width, fillchar)：返回一个指定宽度的居中对齐的字符串，使用 fillchar 填充空白部分。width 是最终字符串的总宽度，fillchar（可选）是用于填充的字符，默认为空格。
message = "Hello"
centered_message = message.center(10, "*")
print(centered_message)  # 输出: "**Hello***"

**Hello***

# ljust(width, fillchar)：返回一个指定宽度的左对齐的字符串，使用 fillchar 填充空白部分。width 是最终字符串的总宽度，fillchar（可选）是用于填充的字符，默认为空格。
message = "Hello"
left_aligned_message = message.ljust(10, "*")
print(left_aligned_message)  # 输出: "Hello*****"

Hello*****

# rjust(width, fillchar)：返回一个指定宽度的右对齐的字符串，使用 fillchar 填充空白部分。width 是最终字符串的总宽度，fillchar（可选）是用于填充的字符，默认为空格。
message = "Hello"
right_aligned_message = message.rjust(10, "*")
print(right_aligned_message)  # 输出: "*****Hello"

*****Hello

# zfill(width)：返回一个指定宽度的字符串，如果字符串长度小于 width，则在左侧填充“0”字符使其达到指定的宽度。
number = "42"
padded_number = number.zfill(6)
print(padded_number)  # 输出: "000042"

000042

expandtabs()

expandtabs() 是一个用于替换字符串中的制表符（\t）为指定数量空格的方法。默认情况下，制表符会被替换为一个空格字符（\t -> ' '）。

expandtabs() 方法的语法如下：

string.expandtabs(tabsize=8)
  • tabsize（可选）用于指定制表符展开后的空格数量。默认值为 8。
message = "Hello\tWorld!"
expanded_message = message.expandtabs()
print(expanded_message)  # 输出: "Hello   World!"

numbers = "1\t2\t3\t4"
expanded_numbers = numbers.expandtabs(4)
print(expanded_numbers)  # 输出: "1   2   3   4"
#expandtabs() 方法会将字符串中的制表符替换为指定数量的空格字符，从而实现文本的列对齐或格式化。

Hello   World!
1   2   3   4

captalize()、swapcase()、title()

# capitalize()：将字符串的第一个字符转换为大写，并将其余字符转换为小写。这个方法返回一个新的字符串。
message = "hello, world!"
capitalized_message = message.capitalize()
print(capitalized_message)  # 输出: "Hello, world!"

Hello, world!

# swapcase()：将字符串中的大写字母转换为小写字母，将小写字母转换为大写字母。这个方法返回一个新的字符串。
message = "Hello, World!"
swapped_case_message = message.swapcase()
print(swapped_case_message)  # 输出: "hELLO, wORLD!"

hELLO, wORLD!

# title()：将字符串中每个单词的首字母转换为大写字母，其他字母转换为小写字母。这个方法返回一个新的字符串。
message = "hello, world!"
title_message = message.title()
print(title_message)  # 输出: "Hello, World!"

Hello, World!

is数字系列（只是为了告诉你，判断是否为数字时除了中文数字以后使用isdigit()即可）

  • isdecimal(): 检查字符串是否值包含十进制字符，如果是返回True，否则返回False。
  • isdigit(): 如果字符串只包含数字则返回True，否则返回False。
  • isnumeric(): 如果字符串中只包含数字字符，则返回True，否则返回False。
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数字（单字节）

================
import unicodedata

unicodedata.digit("2")   # 2
unicodedata.decimal("2") # 2
unicodedata.numeric("2") # 2.0

unicodedata.digit("2")   # 2
unicodedata.decimal("2") # 2
unicodedata.numeric("2") # 2.0

unicodedata.digit(b"3")   # TypeError: must be str, not bytes
unicodedata.decimal(b"3") # TypeError: must be str, not bytes
unicodedata.numeric(b"3") # TypeError: must be str, not bytes

unicodedata.digit("Ⅷ")   # ValueError: not a digit
unicodedata.decimal("Ⅷ") # ValueError: not a decimal
unicodedata.numeric("Ⅷ") # 8.0

unicodedata.digit("四")   # ValueError: not a digit
unicodedata.decimal("四") # ValueError: not a decimal
unicodedata.numeric("四") # 4.0

#"〇","零","一","壱","二","弐","三","参","四","五","六","七","八","九","十","廿","卅","卌","百","千","万","万","亿"

is其他

  • isalnum(): 如果字符串至少有一个字符并且所有字符都是字母或数字则返回True，否则返回False。
  • isalpha(): 如果字符串至少有一个字符并且所有字符都是字母则返回True，否则返回False。
  • islower(): 如果字符串中只包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回True，否则返回False。
  • isspace(): 如果字符串中只包含空白，则返回True，否则返回False
  • isupper(): 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回True，否则返回False。
  • istitle(): 如果字符串是标题类型的(见title())，则返回True，否则返回False。

列表类型内置方法（list）

优先掌握

  • 按索引取值（正向取值+反向取值），即可存也可以取
  • 切片
  • 长度len
  • 成员运算in和not in
  • 追加append
  • 删除del
  • 循环

按索引取值（正向取值+反向取值），即可存也可以取

# list之索引取值
name_list = ['nick', 'jason', 'tank', 'sean']
name_list[0] = 'nick handsom'
# name_list[1000] = 'tank sb'  # 报错

print(f"name_list[0]: {name_list[0]}")

name_list[0]: nick handsom

切片

# list之切片
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"name_list[0:3:2]: {name_list[0:3:2]}")

name_list[0:3:2]: ['nick', 'tank']

长度

# list之长度
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"len(name_list): {len(name_list)}")

len(name_list): 4

成员运算in和not in

# list之成员运算in和not in
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"'tank' in name_list: {'tank' in name_list}")
print(f"'nick handsome' not in name_list: {'nick handsome' not in name_list}")

'tank' in name_list: True
'nick handsome' not in name_list: True

追加值

# list之追加值
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.append('tank sb')

print(f"name_list: {name_list}")

name_list: ['nick', 'jason', 'tank', 'sean', 'tank sb']

对于列表（list）的追加值操作，可以使用 append() 方法向列表末尾添加一个元素。

  • append() 方法会直接修改原来的列表，将新元素添加到列表的末尾。
  • 如果你需要向列表中添加多个元素，你可以使用 extend() 方法。

注意，extend() 方法接受一个可迭代对象作为参数，并将该可迭代对象中的元素逐一添加到列表中。

name_list = ['nick', 'jason', 'tank', 'sean']
name_list.extend(['alice', 'bob'])
print(f"name_list: {name_list}")

name_list: ['nick', 'jason', 'tank', 'sean', 'alice', 'bob']

删除

# list之删除
name_list = ['nick', 'jason', 'tank', 'sean']
del name_list[2]

print(f"name_list: {name_list}")

name_list: ['nick', 'jason', 'sean']

循环

# list之循环
name_list = ['nick', 'jason', 'tank', 'sean']

for name in name_list:
    print(name)

nick
jason
tank
sean

需要掌握

  • insert
  • pop
  • remove
  • count
  • index
  • clear
  • copy
  • extend
  • reverse
  • sort

insert()

# list之insert()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.insert(1, 'handsome')

print(f"name_list: {name_list}")

name_list: ['nick', 'handsome', 'jason', 'tank', 'sean']

pop()

# list之pop()，   默认情况下，pop() 方法会删除并返回列表中的最后一个元素。
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"name_list.pop(1): {name_list.pop(1)}")
print(f"name_list: {name_list}")

name_list.pop(1): jason
name_list: ['nick', 'tank', 'sean']

remove()

# list之remove()
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"name_list.remove('nick'): {name_list.remove('nick')}")
print(f"name_list: {name_list}")

name_list.remove('nick'): None
name_list: ['jason', 'tank', 'sean']

remove() 方法会直接修改原来的列表，并不返回被删除的元素。在这个例子中，使用 print(f"name_list.remove('nick'): {name_list.remove('nick')}") 会输出 None，因为 remove() 方法不返回任何值。

如果被删除的元素在列表中出现多次，remove() 方法只会删除第一个匹配到的元素。

count()

# list之count()
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"name_list.count('nick'): {name_list.count('nick')}")

name_list.count('nick'): 1

对于列表（list）中某个元素的计数操作，可以使用 count() 方法来统计该元素在列表中出现的次数。如果被计数的元素在列表中不存在，则 count() 方法返回 0。

index()

# list之index()
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"name_list.index('nick'): {name_list.index('nick')}")

name_list.index('nick'): 0

对于列表（list）中某个元素的索引查找操作，可以使用 index() 方法来返回该元素在列表中第一次出现的索引。
需要注意的是，index() 方法只返回第一次出现的索引。如果列表中有多个相同的元素，只会返回第一个出现的索引。

如果被查找的元素不在列表中，则会抛出 ValueError 异常。

clear()

# list之clear()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.clear()

print(f"name_list: {name_list}")

name_list: []

对于列表（list）的清空操作，可以使用 clear() 方法来移除列表中的所有元素，使其变为空列表。
clear() 方法直接修改原来的列表，不返回任何值。

copy()

# list之copy()
name_list = ['nick', 'jason', 'tank', 'sean']

print(f"name_list.copy(): {name_list.copy()}")

name_list.copy(): ['nick', 'jason', 'tank', 'sean']

对于列表（list）的复制操作，可以使用 copy() 方法来创建一个新的列表，其中包含原列表的所有元素。

注意，使用 copy() 方法创建的是一个浅拷贝（shallow copy），即新列表中的元素对象和原列表中的元素对象是相同的，它们共享内存地址。这意味着，如果在新列表中修改其中一个元素，原列表中的对应元素也会随之改变。

如果需要创建一个深拷贝（deep copy），即新列表中的元素对象与原列表中的元素对象完全独立，可以考虑使用 copy.deepcopy() 方法。

extend()

# list之extend()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list2 = ['nick handsome']
name_list.extend(name_list2)

print(f"name_list: {name_list}")

name_list: ['nick', 'jason', 'tank', 'sean', 'nick handsome']

reverse()

# list之reverse()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.reverse()

print(f"name_list: {name_list}")

name_list: ['sean', 'tank', 'jason', 'nick']

对于列表（list）的反转操作，可以使用 reverse() 方法来反转列表中元素的顺序。

reverse() 方法直接修改原来的列表，不返回任何值。

需要注意的是，reverse() 方法只会反转列表中元素的顺序，并不会对元素本身进行任何操作或改变。

sort()

# list之sort()，使用sort列表的元素必须是同类型的
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.sort()

print(f"name_list: {name_list}")

name_list.sort(reverse=True)
print(f"name_list_reverse: {name_list}")

name_list: ['jason', 'nick', 'sean', 'tank']
name_list_reverse: ['tank', 'sean', 'nick', 'jason']

对于列表（list）的排序操作，可以使用 sort() 方法来对列表中的元素进行排序。

可以看到，经过 sort() 方法的调用后，name_list 列表中的元素被按照字母顺序进行了升序排序。

如果需要进行降序排序，可以使用 sort(reverse=True)

注意，sort() 方法会直接修改原列表，不返回任何值。

另外，需要注意的是，sort() 方法要求列表中的元素必须是同类型的，否则会抛出 TypeError 异常。

元组类型内置方法（tuple）

元组是不可变的列表，即元组的值不可更改，因此元组一般只用于只存不取的需求。也因此元组可以被列表取代掉，所以元组相比较列表使用的很少。元组相比较列表的优点为：列表的值修改后，列表的结构将会发生改变，而元组只需要存储，因此列表在某种程度上而言需要占用更多的内存。但是目前工业上内存已经不是问题了，所以工业上元组一般不会使用。

#在()内可以有多个任意类型的值，逗号分隔元素

# my_girl_friend = tuple(('jason','tank','sean'))
my_girl_friend = ('jason', 'tank', 'sean')

print(f"my_girl_friend: {my_girl_friend}")

my_girl_friend: ('jason', 'tank', 'sean')

优先掌握

  • 索引取值
  • 切片（顾头不顾尾，步长）
  • 长度len
  • 成员运算in和not in
  • 循环
  • count
  • index

索引取值

# tuple之索引取值
name_tuple = ('nick', 'jason', 'tank', 'sean')
# name_tuple[0] = 'nick handsom'  # 报错

print(f"name_tuple[0]: {name_tuple[0]}")

name_tuple[0]: nick

切片（顾头不顾尾，步长）

# tuple之切片
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple[1:3:2]: {name_tuple[1:3:2]}")

name_tuple[1:3:2]: ('jason',)

长度

# tuple之长度
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"len(name_tuple): {len(name_tuple)}")

len(name_tuple): 4

成员运算

# tuple之成员运算
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"'nick' in name_tuple: {'nick' in name_tuple}")

'nick' in name_tuple: True

循环

# tuple之循环
name_tuple = ('nick', 'jason', 'tank', 'sean')

for name in name_tuple:
    print(name)

nick
jason
tank
sean

count()

# tuple之count()
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple.count('nick'): {name_tuple.count('nick')}")

name_tuple.count('nick'): 1

对于元组（tuple）的计数操作，可以使用 count() 方法来统计特定元素在元组中出现的次数。

如果元组中不存在该元素，count() 方法返回的结果是 0。

index()

# tuple之index()
name_tuple = ('nick', 'jason', 'tank', 'sean')

print(f"name_tuple.index('nick'): {name_tuple.index('nick')}")

name_tuple.index('nick'): 0

对于元组（tuple）的索引操作，可以使用 index() 方法来找到特定元素在元组中的索引位置。

需要注意的是，index() 方法只返回第一次出现的索引位置。如果元组中不存在该元素，index() 方法会抛出 ValueError 异常。

元组和列表的区别

列表可变的原因是：索引所对应的值的内存地址是可以改变的

元组不可变的原因是：索引所对应的值的内存地址是不可以改变的，或者反过来说，只要索引对应值的内存地址没有改变，那么元组是始终没有改变的。

t1 = (['a', 'b', 'c'], 'wc', 'office')

print(f"id(t1[0]): {id(t1[0])}")
print(f"id(t1[1]): {id(t1[1])}")
print(f"id(t1[2]): {id(t1[2])}")

t1[0][0] = 'A'
print(f"t1[0][0]: {t1[0][0]}")
print(f"id(t1[0]): {id(t1[0])}")
print(f"t1: {t1}")

id(t1[0]): 2133796376072
id(t1[1]): 2133771892808
id(t1[2]): 2133796872744
t1[0][0]: A
id(t1[0]): 2133796376072
t1: (['A', 'b', 'c'], 'wc', 'office')

字典类型内置方法（dict）

1.用途：存多个值，但每一个值都有一个key与之对应，key对值有描述功能。多用于存的值表示的是不同的状态时，例如存的值有姓名、年龄、身高、体重、爱好。

2.定义：{}内用逗号分隔开多个元素，每一个元素都是key：value的形式，value可以是任意数据类型，而key通常应该是字符串类型，但是key必须为不可变类型

优先掌握

  • 按key存取值：可存可取
  • 长度len
  • 成员运算in和not in
  • 删除del
  • 键keys()、值values()、键值对items()
  • 循环

按key存取值：可存可取

# dic之按key存取值
dic = {'a': 1, 'b': 2}

print(f"first dic['a']: {dic['a']}")

dic['a'] = 3

print(f"second dic['a']: {dic['a']}")

first dic['a']: 1
second dic['a']: 3

长度len

# dic之长度len
dic = {'a': 1, 'b': 2}

print(f"len(dic): {len(dic)}")

len(dic): 2

成员运算in和not in

# dic之成员运算in和not in
dic = {'a': 1, 'b': 2}

print(f"'a' in dic: {'a' in dic}")
print(f"1 in dic: {1 in dic}")

'a' in dic: True
1 in dic: False

删除

# dic之删除del
dic = {'a': 1, 'b': 2}
del dic['a']

print(f"dic.get('a'): {dic.get('a')}")

dic.get('a'): None

在字典（dict）中，可以使用 del 关键字来删除特定的键值对。

dic.get('a') 返回了 None，表示键 'a' 已经被成功删除，因此再次获取 'a' 对应的值时，返回的是 None。

需要注意的是，使用 del 关键字删除字典中不存在的键时，会抛出 KeyError 异常。为避免异常，可以使用 dict.get() 方法来获取键对应的值，如果键不存在，则返回指定的默认值。

# dic之删除pop()
dic = {'a': 1, 'b': 2}
dic.pop('a')  # 指定元素删除

print(f"dic.pop('b'): {dic.pop('b')}")
print(f"dic.get('a'): {dic.get('a')}")


dic.pop('b'): 2
dic.get('a'): None

在字典（dict）中，可以使用 pop() 方法来删除指定的键值对，并返回被删除的值。

dic.pop('b') 返回了值 2，表示成功删除了键为 'b' 的键值对，并返回了其对应的值。

而 dic.get('a') 返回了 None，表示键 'a' 已经被成功删除，再次获取 'a' 对应的值时返回的是 None。

需要注意的是，如果执行 pop() 方法时指定的键不存在于字典中，则会抛出 KeyError 异常。为避免异常，你可以传递第二个参数给 pop() 方法作为默认值，在这种情况下，如果指定的键不存在，则返回默认值而不会抛出异常。

# dic之删除popitem()
dic = {'a': 1, 'b': 2}

print(f"dic.popitem(): {dic.popitem()}")  # popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。

dic.popitem(): ('b', 2)

在字典（dict）中，可以使用 popitem() 方法随机返回并删除字典中的一对键和值。注意，一般情况下，该方法会删除字典中的最后一对键值对。

可以看到，dic.popitem() 返回了 ('b', 2)，表示成功删除了字典中的一对键值对，其中 'b' 是被删除的键，2 是被删除的值。

需要注意的是，字典是无序的数据结构，所以 popitem() 方法删除的键值对是随机的。如果字典为空，则会抛出 KeyError 异常。

键keys()、值values()、键值对items()

# dic之键keys()、值values()、键值对items()，python2中取出的是列表（鸡蛋）；python3中取出的是元组（鸡）
dic = {'a': 1, 'b': 2}

print(f"dic.keys(): {dic.keys()}")
print(f"dic.values(): {dic.values()}")
print(f"dic.items(): {dic.items()}")

dic.keys(): dict_keys(['a', 'b'])
dic.values(): dict_values([1, 2])
dic.items(): dict_items([('a', 1), ('b', 2)])

循环

# dic之循环
# dic是无序的，但是python3采用了底层优化算法，所以看起来是有序的，但是python2中的字典是无序
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

for k, v in dic.items():  # items可以换成keys()、values()
    print(k, v)

a 1
b 2
c 3
d 4

需要掌握

  • get
  • update
  • fromkeys
  • setdefault

get()

# dic之get()
dic = {'a': 1, 'b': 2}

print(f"dic.get('a'): {dic.get('a')}")
print(f"dic.get('c'): {dic.get('c')}")

dic.get('a'): 1
dic.get('c'): None

update()

# dic之update()
dic1 = {'a': 1, 'b': 2}
dic2 = {'c': 3}
dic1.update(dic2)

print(f"dic1: {dic1}")

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

在字典中，可以使用 update() 方法将一个字典的键值对添加到另一个字典中或更新现有的键值对。

如果被更新的字典中的键已经存在于目标字典中，则会用新的值进行更新。

需要注意的是，update() 方法会直接修改被更新的字典，并不会返回一个新的字典。

fromkeys()

# dic之fromkeys()
dic = dict.fromkeys(['name', 'age', 'sex'], None)

print(f"dic: {dic}")

dic: {'name': None, 'age': None, 'sex': None}

在字典中，可以使用 fromkeys() 方法创建一个新的字典，其中包含指定的键和相应的默认值。

在例子中，你使用 fromkeys() 方法创建了一个新的字典 dic，其中的键来自列表 ['name', 'age', 'sex']，而默认值被设置为 None。

然后打印输出了新创建的字典 dic。

可以看到，通过 dict.fromkeys(['name', 'age', 'sex'], None) 创建的字典 dic 包含了三个键值对，即 'name': None、'age': None 和 'sex': None。这里使用的默认值是 None，也可以根据需要设置其他默认值。

需要注意的是，fromkeys() 方法是类方法，需要通过类名 dict 调用，而不是实例对象。

setdefault()

# dic之setdefault()，有指定key不会改变值；无指定key则改变值
dic = {'a': 1, 'b': 2}

print(f"dic.setdefault('a'): {dic.setdefault('a',3)}")
print(f"dic: {dic}")
print(f"dic.setdefault('c'): {dic.setdefault('c',3)}")
print(f"dic: {dic}")

dic.setdefault('a'): 1
dic: {'a': 1, 'b': 2}
dic.setdefault('c'): 3
dic: {'a': 1, 'b': 2, 'c': 3}

在字典中，可以使用 setdefault() 方法获取指定键的值，如果键不存在，则可以指定一个默认值，并将其添加到字典中。

可以看到，使用 dic.setdefault('a', 3) 获取键 'a' 对应的值时，返回的是 1，并且字典 dic 的内容没有变化。而当使用 dic.setdefault('c', 3) 获取键 'c' 对应的值时，返回的是指定的默认值 3，并且键值对 'c': 3 被添加到了字典 dic 中。

需要注意的是，如果指定的键存在于字典中，则 setdefault() 方法不会修改该键对应的值，而是返回已存在的值。只有当指定的键不存在时，才会使用默认值并将其添加到字典中。

集合类型内置方法(set)

pythoners = ['jason', 'nick', 'tank', 'sean']
linuxers = ['nick', 'egon', 'kevin']

# 即报名pythoners又报名linux的学生
py_li_list = []
for stu in pythoners:
    if stu in linuxers:
        py_li_list.append(stu)
print(f"pythoners and linuxers: {py_li_list}")

pythoners and linuxers: ['nick']

上述的列表方式求两个集合体的关系运算非常复杂，因此有了集合数据类型。

1.用途：用于关系运算的集合体，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。

2.定义：{}内用逗号分隔开多个元素，每个元素必须是不可变类型。

s = {1, 2, 1, 'a'}  # s = set({1,2,'a'})

print(f"s: {s}")

s: {'a', 1, 2}

s = {1, 2, 1, 'a', 'c'}

for i in s:
    print(i)

a
1
2
c

s = set('hello')

print(f"s: {s}")

s: {'o', 'l', 'h', 'e'}

优先掌握

  • 长度len
  • 成员运算in和not in
  • |并集、union
  • &交集、intersection
  • -差集、difference
  • ^对称差集、symmetric_difference
  • ==
  • 父集：>、>= 、issuperset
  • 子集：<、<= 、issubset

长度len

# set之长度len
s = {1, 2, 'a'}

print(f"len(s): {len(s)}")

len(s): 3

s = {1, 2, 2, 'a'}

print(f"len(s): {len(s)}")

len(s): 3

在集合中，元素是唯一且不重复的。因此，无论有多少个重复的元素，它们在集合中只会被计数一次。

需要注意的是，这种和集合中元素唯一性相关的特性，使得集合常常被用于去重或查找元素的操作

成员运算in和not in

# set之成员运算in和not in
s = {1, 2, 'a'}

print(f"1 in s: {1 in s}")

1 in s: True

|并集

# str之|并集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners|linuxers: {pythoners|linuxers}")
print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}")

pythoners|linuxers: {'kevin', 'nick', 'jason', 'egon', 'tank', 'sean'}
pythoners.union(linuxers): {'kevin', 'nick', 'jason', 'egon', 'tank', 'sean'}

可以看到，pythoners|linuxers 和 pythoners.union(linuxers) 都返回了包含了两个集合中所有元素的新集合（即并集）。

需要注意的是，并集操作不会改变原始集合，而是返回一个包含并集元素的新集合。这可以防止原始集合的改变，因为集合是可变的（mutable）对象。

&交集

# str之&交集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners&linuxers: {pythoners&linuxers}")
print(f"pythoners.intersection(linuxers): {pythoners.intersection(linuxers)}")

pythoners&linuxers: {'nick'}
pythoners.intersection(linuxers): {'nick'}

可以看到，pythoners&linuxers 和 pythoners.intersection(linuxers) 都返回了一个新集合，其中包含了两个集合中共同的元素（即交集）。

需要注意的是，交集操作不会改变原始集合，而是返回一个包含交集元素的新集合。这可以防止原始集合的改变，因为集合是可变的（mutable）对象。

-差集

# str之-差集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners-linuxers: {pythoners-linuxers}")
print(f"pythoners.difference(linuxers): {pythoners.difference(linuxers)}")

pythoners-linuxers: {'jason', 'tank', 'sean'}
pythoners.difference(linuxers): {'jason', 'tank', 'sean'}

pythoners-linuxers 和 pythoners.difference(linuxers) 都返回了一个新集合，其中包含了在 pythoners 中存在但不在 linuxers 中存在的元素 （即差集）。

需要注意的是，差集操作不会改变原始集合，而是返回一个包含差集元素的新集合。这可以防止原始集合的改变，因为集合是可变的（mutable）对象。

^对称差集

# str之^对称差集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}

print(f"pythoners^linuxers: {pythoners^linuxers}")
print(
    f"pythoners.symmetric_difference(linuxers): {pythoners.symmetric_difference(linuxers)}")

pythoners^linuxers: {'kevin', 'tank', 'jason', 'egon', 'sean'}
pythoners.symmetric_difference(linuxers): {'kevin', 'tank', 'jason', 'egon', 'sean'}

pythoners^linuxers 和 pythoners.symmetric_difference(linuxers) 都返回了一个新集合，其中包含了两个集合中不相交的元素（即对称差集）。 也就是去掉两个集合重复的后的并集

需要注意的是，对称差集操作不会改变原始集合，而是返回一个包含对称差集元素的新集合。这可以防止原始集合的改变，因为集合是可变的（mutable）对象。

==

# str之==
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javers = {'nick', 'egon', 'kevin'}

print(f"pythoners==linuxers: {pythoners==linuxers}")
print(f"javers==linuxers: {javers==linuxers}")

pythoners==linuxers: False
javers==linuxers: True

在Python中，可以使用 == 运算符来检查两个集合是否相等。

需要注意的是，集合的相等性是基于它们的元素是否相同，而不依赖于它们的顺序。如果两个集合具有相同的元素，无论是哪个顺序，它们都被认为是相等的。

父集：>、>=

# str之父集：>、>=
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}

print(f"pythoners>linuxers: {pythoners>linuxers}")
print(f"pythoners>=linuxers: {pythoners>=linuxers}")
print(f"pythoners>=javaers: {pythoners>=javaers}")
print(f"pythoners.issuperset(javaers): {pythoners.issuperset(javaers)}")

pythoners>linuxers: False
pythoners>=linuxers: False
pythoners>=javaers: True
pythoners.issuperset(javaers): True

由于 pythoners 包含linuxers中所有的元素，因此这两个比较表达式也都返回了 True。

pythoners.issuperset(javaers) 表达的是 pythoners 是否是 javaers 的父集或者相等。

子集：<、<=

# str之子集：<、<=
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}

print(f"pythoners<linuxers: {pythoners<linuxers}")
print(f"pythoners<=linuxers: {pythoners<=linuxers}")
print(f"javaers.issubset(javaers): {javaers.issubset(javaers)}")

pythoners<linuxers: False
pythoners<=linuxers: False
javaers.issubset(javaers): True

pythoners<linuxers 和 pythoners<=linuxers 都返回了 False，表示 pythoners 不是 linuxers 的子集。因为 pythoners 包含了linuxers中没有的元素。

而对于 javaers.issubset(javaers)，返回了 True，因为 javaers 是自身的子集（即一个集合是其自身的子集）。

需要注意的是，< 运算符用于检查是否是真正的子集关系，即一个集合包含另一个集合的所有元素，并且两个集合不相等。而 <= 运算符用于检查是否是子集或相等的关系，即一个集合包含另一个集合的所有元素，可以相等。issubset() 方法也是用于检查是否是子集关系。

需要掌握

  • add
  • remove
  • difference_update
  • discard
  • isdisjoint

add()

# set之add()
s = {1, 2, 'a'}
s.add(3)

print(s)

{'a', 1, 2, 3}

需要注意的是，集合是无序的，元素的顺序可能与添加的顺序不同。

remove()

# set之remove()
s = {1, 2, 'a'}
s.remove(1)

print(s)

{'a', 2}

difference_update()

# str之difference_update()
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.difference_update(linuxers)

print(f"pythoners.difference_update(linuxers): {pythoners}")

pythoners.difference_update(linuxers): {'sean', 'tank', 'jason'}

在Python中，可以使用 difference_update() 方法从一个集合中移除与其他集合中的元素相同的元素，更新原始集合。

pythoners.difference_update(linuxers) 后，pythoners 集合中移除了与 linuxers 集合中相同的元素。在这种情况下，'nick' 被移除了。

需要注意的是，difference_update() 方法会直接修改原始集合，而不会创建一个新的集合。

discard()

# set之discard()
s = {1, 2, 'a'}
# s.remove(3)  # 报错
s.discard(3)

print(s)

{'a', 1, 2}

在Python中，可以使用 discard() 方法从集合中移除指定的元素。与 remove() 不同的是，如果要删除的元素不存在于集合中，discard() 方法不会引发错误，而是默默返回而已。

需要注意的是，如果要移除的元素存在于集合中，那么使用 discard() 方法和 remove() 方法的结果是相同的。而当要移除的元素不存在于集合中时，remove() 方法会引发 KeyError 错误，而 discard() 方法则不会引发错误。

isdisjoint()

# set之isdisjoint()，集合没有共同的部分返回True，否则返回False
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.isdisjoint(linuxers)

print(f"pythoners.isdisjoint(linuxers): {pythoners.isdisjoint(linuxers)}")

pythoners.isdisjoint(linuxers): False

数据类型分类

深浅拷贝

在python中，对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用

一般有三种方法，分别为：拷贝（赋值）、浅拷贝、深拷贝

可变或不可变

  • id不变值可变，即在原值的基础上修改，则为可变数据类型；
  • 值变id也变，即重新申请一个空间放入新值，则为不可变数据类型。
age = 19
print(f'first:{id(age)}')
age = 20
print(f'second:{id(age)}')

first:1906339872
second:1906339904

拷贝

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = l1
print(id(11))

l1.append('g')

print(l1)
print(id(11))

1906339616
['a', 'b', 'c', ['d', 'e', 'f'], 'g']
1906339616

print(l2)
print(id(12))

['a', 'b', 'c', ['d', 'e', 'f'], 'g']
1906339648

l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变。

浅拷贝

l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变。

import copy

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.copy(l1)

l1.append('g')

print(l1)

['a', 'b', 'c', ['d', 'e', 'f'], 'g']

print(l2)

['a', 'b', 'c', ['d', 'e', 'f']]

l1[3].append('g')

print(l1)

['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']

print(l2)

['a', 'b', 'c', ['d', 'e', 'f', 'g']]

深拷贝

l2是l1的深拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化。

import copy

l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
l2 = copy.deepcopy(l1)

l1.append('g')

print(l1)

['a', 'b', 'c', ['d', 'e', 'f'], 'g']

print(l2)

['a', 'b', 'c', ['d', 'e', 'f']]

l1[3].append('g')

print(l1)

['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']

print(l2)

['a', 'b', 'c', ['d', 'e', 'f']]

标签：name,pythoners,day03,list,dic,nick,print
From： https://www.cnblogs.com/qingchuan/p/17561000.html

相关文章

  • day03 链表基本操作
    前置知识，链表数据结构1.移除链表元素移除链表元素不难，只需要把前一个结点的下一节点指向下一个节点的下一节点如果当前遍历的节点与所给值相等，则需要移除此元素，移除元素是将上一节点的next域设置为当前节点的next，当前节点后移一位如果当前遍历的节点值不等于所给值，则前驱......
  • java学习day03:循环结构
    我在B站上大学......
  • Day03-15 方法
    1、何谓方法?Java方法是语句的集合，它们在一起执行一个功能。方法是解决一类问题的步骤的有序组合方法包含于类或对象中方法在程序中被创建，在其他地方被引用设计方法的原则方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原......
  • Day03-13 break、continue、goto
    breakbreak在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。(break语句也在switch语句中使用)    inti=0;    while(i<100){      i++;      System.out.println(i);  ......
  • Day03-14 打印三角形
    打印三角形    //打印三角形5行    for(inti=1;i<=5;i++){      for(intj=5;j>=i;j--){        System.out.print("");     }      for(intj=1;j<=i;j++){        Syst......
  • JAVA_DAY03
    第三天赋值运算符:基础赋值运算符:=是唯一一个自右向左运算的符号扩展赋值运算符:(基础赋值运算符+算数运算符)推荐使用扩展赋值运算符在编译期间,满足条件的代码会自动优化成为扩展赋值运算符比较|关系运算符:<><=>=操作数只能为数值型的操作数byt......
  • 算法学习day03链表part01-203、707、206
    packageSecondBrush.LinkedList.LL1;/***203.移除链表元素*删除链表中等于给定值val的所有节点。*自己再次概述一下这个过程：*1.移除元素，要采用设置虚拟节点的方式，因为那样不需要考虑头结点问题*2.设置两个虚拟指向*3.移除元素就是遍历链表，然后碰到目标值......
  • 八期day03-反编译工具和hook框架
    一反编译工具1.1常见反编译工具常见的反编译工具：jadx（推荐）、jeb、GDA反编译工具依赖于java环境，所以我们按照jdk1.2JDK环境安装#官方地址：（需要注册-最新java21）https://www.oracle.com/java/technologies/downloads/#下载地址链接:https://pan.baidu.com/s/1JxmjfGhW......
  • 算法与数据结构Day03——平衡二叉树的根
    #include<stdio.h>#include<stdlib.h>typedefstructnode*AVLTree;structnode{intData;AVLTreeLeft;AVLTreeRight;};intHigh(AVLTreeT){if(!T)return0;intleft=High(T->Left)+1;intright=High(T->......
  • Day03 3.3 使用Python还原算法
    Day033.3使用Python还原算法加密分类1、单向加密：MD5、sha系列不可逆2、对称加密：AES、DES3、非对称加密：RSA、DSA4、补充算法：base64【一】md5importhashlibm=hashlib.md5()m.update('helloworld'.encode("utf8"))print(m.hexdigest())【二......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99