首页 > 其他分享 >八大数据类型

八大数据类型

时间：2023-11-27 19:33:50浏览次数：26  
标签：八大 sentence text format 数据类型 number 字符串 print

概念

Python中有许多数据类型，但常用的八大数据类型包括：

  1. 整数（int）: 表示整数值，例如：x = 10

  2. 浮点数（float）: 表示带有小数点的数值，例如：y = 3.14

  3. 字符串（str）: 表示文本数据，例如：text = "Hello, World!"

  4. 列表（list）: 有序可变序列，可以包含不同类型的元素，例如：my_list = [1, 2, "three"]

  5. 元组（tuple）: 有序不可变序列，用于保存有关联的元素，例如：my_tuple = (1, 2, "three")

  6. 集合（set）: 无序可变集合，用于存储唯一元素，例如：my_set = {1, 2, 3}

  7. 字典（dict）: 无序的键-值对集合，用于存储相关数据，例如：my_dict = {'name': 'John', 'age': 25}

  8. 布尔值（bool）: 表示真（True）或假（False），用于逻辑判断，例如：is_true = True

整数和浮点数

# 整型
number = 18  

print(number)               # 18
print(type(number))         # <class 'int'>
print(id(number))           # 140705976863704

# 浮点型
number_float = 18.6         
print(number_float)         # 18.6
print(type(number_float))   # <class 'float'>
print(id(number_float))     # 1864376363952

# 四则运算
x = 18
y = 5

print(x + y)    # 23 
print(x - y)    # 13
print(x * y)    # 90
print(x / y)    # 3.6 tips: 只要运算了除法，结果必然是浮点数

int相关用法

int("0o52", 8)  # 42
int("0b101010", 2) # 42
int("0x2a", 16)  # 42

数字转进制

# 16进制
hex(42)  # '0x2a'
# 2进制
bin(42)  # '0b101010'
# 8进制
oct(42)  # '0o52'

字符串

定义一个字符串

name = "小满"
age = 3

sentence = """
山腰的风景很美
然而
我还是
想去山顶看看
"""

字符串的嵌套

外面是单引号, 里面的字符串使用双引号

外面是双引号, 里面的字符串使用单引号

content = '编程里有一个DRY原则: "Don\'t repeat your self."'
print(content)  # 编程里有一个DRY原则: "Don't repeat your self."

content = "编程里有一个DRY原则: 'Do not repeat your self.'"
print(content)  # 编程里有一个DRY原则: 'Do not repeat your self.'

原始字符串

使用原始字符串, 就是在字符串最前面加上一个r, 一般情况下正则用的会比较多

# 未使用原始字符串
path = "c:\teacher\homework"
print(path) # c:	eacher\homework

# 使用了原始字符串
path = r"c:\teacher\homework"
print(path)  # c:\teacher\homework

字符串相加

first_name = "jack"
last_name = "chen"
full_name = first_name + " " + last_name

print(full_name)  # jack chen

字符串相乘

word = "ha"
sentence = "He said " + word * 5

print(sentence)  # He said hahahahaha

字符串索引

索引从0开始，在字符串中取值可以使用str[index]的方法去取值，-1为最后一个值。

image-20231127151342408

sentence = "下雨了别跑，反正前面也是雨。"

print(sentence[0])  # 下
print(sentence[-2])  # 雨

查看索引

# 方法1 index
# 找到了返回对应位置，找不到就报错

sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.index("别跑"))  # 3

sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.index("别跑啦"))  # 报错 ValueError: substring not found


# 方法2 find
# 找到了返回对应位置，找不到返回-1

sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.find("前面"))  # 8

sentence = "下雨了别跑，反正前面也是雨。"
print(sentence.find("后面"))  # -1

切片

sentence = "下雨了别跑，反正前面也是雨。"

print(sentence[:3])  # 下雨了
print(sentence[-6:-1])  # 前面也是雨
print(sentence[:])  # 下雨了别跑，反正前面也是雨

统计次数

sentence = "下雨了别跑，反正前面也是雨。"

print(sentence.count("雨"))  # 2
print(sentence.count("跑"))  # 1
print(sentence.count("走"))  # 0

字符串转义

转义字符 说明
\n 换行符，将光标位置移到下一行开头。
\r 回车符，将光标位置移到本行开头。
\t 水平制表符，也即 Tab 键，一般相当于四个空格。
\a 蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b 退格（Backspace），将光标位置移到前一列。
\ 反斜线
' 单引号
" 双引号
\ 在字符串行尾的续行符，即一行未完，转到下一行继续写。

字符串格式化输出

f-string格式化

f-string 是在 Python 3.6 版本引入的一种字符串格式化方法，它允许在字符串中嵌入表达式，并在运行时对它们进行求值。使用 f-string 可以更简洁和直观地进行字符串格式化。

f-string 的语法很简单，只需在字符串前加上字母 'f' 或 'F'，然后在字符串中使用花括号 {} 括起表达式。在花括号中，你可以放置变量、表达式或调用函数。

food = "冰淇淋"
number = 2
sentence = f"“我不会因为一个{food}和你走！” “{number}个” “好那我去收拾行李。”"

print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

.format格式化

基本语法

food = "冰淇淋"
number = 2
sentence = "“我不会因为一个{}和你走！” “{}个” “好那我去收拾行李。”".format(food, number)

print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

位置参数

food = "冰淇淋"
number = 2
sentence = "“我不会因为一个{1}和你走！” “{0}个” “好那我去收拾行李。”".format(number, food)

print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

关键字参数

sentence = "“我不会因为一个{food}和你走！” “{number}个” “好那我去收拾行李。”".format(food="冰淇淋", number=2)
print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

混合使用位置参数和关键字参数

sentence = "“我不会因为一个{}和你走！” “{number}个” “好那我去收拾行李。”".format("冰淇淋", number=2)
print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

解包字典

data = {
    "food": "冰淇淋",
    "number": 2
}

sentence = "“我不会因为一个{food}和你走！” “{number}个” “好那我去收拾行李。”".format(**data)
print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

其他方法补充

# 保留几位小数
# {:.nf} n表示几位小数 
from math import pi

print("The value of pi is approximately: {:.2f}".format(pi))
# The value of pi is approximately: 3.14

# 填充与对齐

number = 42
# {:填充字符 对其方式 共几位} tips:中间无空格
# 尖角号朝左边就是左对齐
# 尖角号朝右边就是右对齐
# ^ 表示居中对齐  tips:英文模式下 shift + 6

# 左对齐 占位10位 右边填充指定字符
print("{:*<10}".format(number))  # 42********
# 右对齐 占位10位 左边填充指定字符
print("{:*>10}".format(number))  # ********42
# 居中对齐 占位10位 左右两侧填充指定字符
print("{:*^10}".format(number))  # ****42****

# 千位分隔符
# 语法 {:,} 

phone_number = 13800138000
print("谁能告诉我这是什么电话号码: {:,}".format(phone_number))  
# 谁能告诉我这是什么电话号码: 13,800,138,000

# 扩展知识
# 在python中，int类型和float类型，如果数字过长，可以使用 _ 下划线去连接

phone_number = 1380_0138_000

print(phone_number)  # 13800138000
print("谁能告诉我这是什么电话号码: {:,}".format(phone_number))
# 谁能告诉我这是什么电话号码: 13,800,138,000

指定宽度和精度

# {:n.3f} 
# n表示一共多少位字符 
	# tips: n的左侧可以填充对其方式以及填充字符 {:0>10.3f}
    #       如何不写默认是右对齐填充空白
# 3表示小数部分的精度
# f表示是一个浮点数

# 字符共10位 右对齐 不足的位置填充*号 小数点保留3位
print("{:*>10.3f}".format(number))
# 字符共10位 右对齐 不足的位置填充空白 小数点保留3位
print("{:10.3f}".format(number))
# 字符共10位 右对齐 不足的位置填充数字0 小数点保留3位
print("{:0>10.3f}".format(number))

# 结果如下

**1234.568
  1234.568
001234.568

进制格式化

decimal_number = 42

# 将整数格式化为二进制，无前缀 "0b"
binary_string = "Binary representation: {:b}".format(decimal_number)
print(binary_string)  # Hex representation with prefix: 101010

# 将整数格式化为八进制，无前缀 "0o"
octal_string = "Octal representation: {:o}".format(decimal_number)
print(octal_string)  # Hex representation with prefix: 52

# 将整数格式化为十六进制，无前缀 "0x"
hex_string = "Hex representation: {:x}".format(decimal_number)
print(hex_string)  # Hex representation with prefix: 2a

# 将整数格式化为十六进制，带有前缀 "0x"
hex_string_with_prefix = "Hex representation with prefix: {:#x}".format(decimal_number)
print(hex_string_with_prefix)  # Hex representation with prefix: 0x2a

format_map格式化

str.format_map(mapping) 是 Python 字符串的方法之一，它用于使用映射对象（通常是字典）中的键值对来替换字符串中的占位符。这个方法类似于 str.format()，但是它接受一个字典作为参数，用字典中的键值对来填充字符串中的占位符。

以下是一个简单的示例：

# 使用 format_map 替换字符串中的占位符
person = {'name': 'Alice', 'age': 30}
sentence = "My name is {name} and I am {age} years old."
formatted_sentence = sentence.format_map(person)

print(formatted_sentence)

在这个例子中，{name} 和 {age} 是占位符，format_map(person) 使用字典中的键值对来替换这些占位符。输出结果将是：

My name is Alice and I am 30 years old.

需要注意的是，format_map() 方法在替换占位符时，如果字典中缺少对应的键，不会引发 KeyError，而是保留占位符不变。这与 format() 方法不同，format() 方法在遇到未知的键时会引发 KeyError。

# 使用 format_map 时不会引发 KeyError
person = {'name': 'Alice'}
sentence = "My name is {name} and I am {age} years old."
formatted_sentence = sentence.format_map(person)

print(formatted_sentence)

输出结果：

My name is Alice and I am {age} years old.

这使得 format_map() 方法在处理部分缺失的数据时更为灵活。

%格式化

food = "冰淇淋"

sentence = "“我不会因为一个%s和你走！” “2个” “好那我去收拾行李。”" % food
print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

number = 2

sentence = "“我不会因为一个冰淇淋和你走！” “%d个” “好那我去收拾行李。”" % number
print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

number = "2"  # 注意，这里是字符串

sentence = "“我不会因为一个冰淇淋和你走！” “%d个” “好那我去收拾行李。”" % number
print(sentence)  # 报错 TypeError: %d format: a real number is required, not str

# 当参数大于1个的时候，百分号右边需要用一共括号括起来

food = "冰淇淋"
number = 2

sentence = "“我不会因为一个%s和你走！” “%d个” “好那我去收拾行李。”" % (food, number)
print(sentence)  # “我不会因为一个冰淇淋和你走！” “2个” “好那我去收拾行李。”

# %.nf 浮点数，n表示保留几位小数

from math import pi

print("The value of pi is approximately: %.2f" % pi)  
# The value of pi is approximately: 3.14

进制格式化

decimal_number = 42

# 将整数格式化为二进制，带有前缀 "0b"
binary_string = "Binary representation: %s" % bin(decimal_number)
print(binary_string)  # Binary representation: 0b101010

# 将整数格式化为八进制，无前缀 "0o"
octal_string = "Octal representation: %o" % decimal_number
print(octal_string)  # Octal representation: 52

# 将整数格式化为十六进制，无前缀 "0x"
hex_string = "Hex representation: %x" % decimal_number
print(hex_string)  # Hex representation: 2a

总结

更推荐使用f-string格式化或者.format格式化

字符串常用方法

dir(str)

text = "hello worLD"

print(f"text的值为 '{text}'")
print("text.title() 输出", text.title())
print("text.lower() 输出", text.lower())
print("text.upper() 输出 ", text.upper())
print("text.swapcase() 输出", text.swapcase())
print("text.ljust(20, '=') 输出", text.ljust(20, "="))
print("text.rjust(20, '=') 输出", text.rjust(20, "="))
print("text.zfill(20) 输出", text.zfill(20))
print("text.find('1') 输出", text.find('1'), "解析: 如果使用find查找, 找不到就是-1")
print("text.find('L') 输出", text.find('L'))
print("text.find('L', 1) 输出", text.find('L', 1), "解析: 第二个参数表示从哪里开始找")
print("text.count('L')  输出", text.count('L'), "解析: 如果找不到不会报错, 会返回0")
print("'11'.isdigit() 输出", '11'.isdigit())
print("'11'.isalnum() 输出", '11'.isalnum())
print("'11'.isaplha() 输出", '11'.isalpha())
print("'11'.isnumeric() 输出", '11'.isnumeric())
# python3.9新增的两个方法
# removeprefix 移除开始的指定字符，如不存在返回整个字符
# removesuffix 移除结尾的指定字符，如不存在返回整个字符
print("text.removeprefix('hello') 输出", text.removeprefix("hello"))
print("text.removesuffix('worLD') 输出", text.removesuffix("worLD"))

结果如下

text的值为 'hello worLD'
text.title() 输出 Hello World
text.lower() 输出 hello world
text.upper() 输出  HELLO WORLD
text.swapcase() 输出 HELLO WORld
text.ljust(20, '=') 输出 hello worLD=========
text.rjust(20, '=') 输出 =========hello worLD
text.zfill(20) 输出 000000000hello worLD
text.find('1') 输出 -1 解析: 如果使用find查找, 找不到就是-1
text.find('L') 输出 9
text.find('L', 1) 输出 9 解析: 第二个参数表示从哪里开始找
text.count('L')  输出 1 解析: 如果找不到不会报错, 会返回0
'11'.isdigit() 输出 True
'11'.isalnum() 输出 True
'11'.isaplha() 输出 False
'11'.isnumeric() 输出 True
text.removeprefix('hello') 输出  worLD
text.removesuffix('worLD') 输出 hello

casefold方法

str.casefold() 是 Python 字符串对象的方法，用于执行字符串的大小写折叠（case folding）。大小写折叠是一种更加广泛的字符匹配方式，通常用于比较字符串而忽略大小写，并且比 str.lower() 更具有 Unicode 兼容性。

在 Python 中，str.casefold() 将字符串中的所有字符转换为小写，并且还考虑了一些特殊字符的 Unicode 等价物。这使得字符串比较更加严格，适用于不同语言和区域的情况。

以下是一个示例：

string1 = "Hello"
string2 = "heLLo"

# 使用 casefold 进行比较
if string1.casefold() == string2.casefold():
    print("Strings are case-insensitive equal.")
else:
    print("Strings are not case-insensitive equal.")

在这个例子中，string1.casefold() 和 string2.casefold() 都将字符串转换为小写，并进行大小写折叠比较。输出结果将是 "Strings are case-insensitive equal."。

使用 str.casefold() 在进行字符串比较时是一种推荐的方式，尤其是当你需要考虑多语言、特殊字符和 Unicode 等价性的情况。

maketrans方法

str.maketrans(x[, y[, z]]) 是 Python 字符串对象的一个类方法，用于创建一个转换表（translation table）对象，这个对象可以在字符串的 translate() 方法中使用，用来执行字符的映射或删除操作。

参数说明：

  • x：单个字符的字符串，表示需要映射的字符集。
  • y：与 x 具有相同长度的字符串，表示将 x 中的字符映射到的字符集。
  • z：字符串，表示要删除的字符集。

如果只提供了 x 参数，它必须是一个长度为 256 的字符串，其中每个字符的 Unicode 码点与其在表中的位置相对应。如果提供了 x 和 y 两个参数，它们必须是等长的字符串，表示字符的一对一映射。如果提供了 z 参数，它是一个字符串，其中包含要删除的字符。

以下是一些示例：

# 创建一个简单的映射表，将 'abc' 映射到 '123'
translation_table = str.maketrans('abc', '123')

# 使用映射表进行字符串的映射
original_string = "abcxyz"
mapped_string = original_string.translate(translation_table)
print(mapped_string)

输出结果：

123xyz

在这个例子中，maketrans('abc', '123') 创建了一个映射表，该表将字符 'a' 映射到 '1'，'b' 映射到 '2'，'c' 映射到 '3'。然后，translate() 方法使用这个映射表将字符串中的字符进行映射。

这个方法常用于一些字符替换或字符删除的操作。

partition方法

str.partition(sep) 是 Python 字符串对象的一个方法，用于根据指定的分隔符 sep 将字符串分割成三部分：分隔符之前的部分、分隔符本身、分隔符之后的部分。如果字符串中不包含分隔符，那么将返回原始字符串和两个空字符串。

以下是一个简单的示例：

text = "python:is:fun"

# 使用 partition() 方法根据 ":" 分割字符串
result = text.partition(":")
print(result)

输出结果：

('python', ':', 'is:fun')

在这个例子中，partition(":") 方法根据冒号 : 将字符串分成三部分。结果是一个包含三个元素的元组，其中第一个元素是分隔符之前的部分，第二个元素是分隔符本身，第三个元素是分隔符之后的部分。

这个方法通常在需要从字符串中提取特定部分时很有用，特别是在处理具有固定格式的字符串时。

结果是元组

列表

列表里面可以放任何数据类型，如果要取值，比字符串更加方便

data_list = [42, 3.14, "浮生六记", {"南康白起": "我等你到35岁"}, True, False, set(), ["我爱你", "与你无关"]]

print(type(data_list))
print(data_list)

# 结果如下

<class 'list'>
[42, 3.14, '浮生六记', {'南康白起': '我等你到35岁'}, True, False, set(), ['我爱你', '与你无关']]

索引取值

data_list = [42, 3.14, "浮生六记", {"南康白起": "我等你到35岁"}, True, False, set(), ["我爱你", "与你无关"]]  
print(data_list[2])  # 浮生六记

嵌套取值

data_list = [42, 3.14, "浮生六记", {"南康白起": "我等你到35岁"}, True, False, set(), ["我爱你", "与你无关"]]

print(data_list[-1][-2])  # 我爱你
print(data_list[3]['南康白起'])  # 我等你到35岁

data_list = [42, 3.14, "浮生六记", {"南康白起": "我等你到35岁"},{'book': ["活着", "杀死一只知更鸟", ("余华", "哈珀·李")]}]
print(data_list[4]['book'][1])  # 杀死一只知更鸟
print(data_list[4]['book'][2][-1])  # 哈珀·李

标签：八大,sentence,text,format,数据类型,number,字符串,print
From： https://www.cnblogs.com/ccsvip/p/17860236.html

相关文章

  • 程序基础之数据类型
    基本数据类型及其占位符 输入占位符输出占位符所占字节数数据范围unsignedint%d%d400~232−1232−1int%d%d4−231−231~231−1231−1longlong%lld%lld8−263−263~263−1263−1float%f%f41.175494351E−381.175494351E−38~3.40282346......
  • 基本数据类型
    基本数据类型（一）数字类型【1】整型int（1）作用整数类型用于表示整数，是一种基本的数字类型，广泛用于表示计数、索引等整数值。（2）整型定义#1.整型定义number=18#查看内存地址print(id(number))#2830603059984#查看数据类型print(type(number))#<class'int'>#查看......
  • 基本数据类型
    数据类型数字类型整数类型(int)浮点类型(float)字符串类型(str)列表类型(list)字典类型(dict)布尔类型(bool)元祖类型(tuple)集合类型(set)【一】数字类型(int/float)【1】整数类型(int)(1)作用整数类型用于表示整数，是一种基本的数字类型，广泛用于表示计数、......
  • 数据类型拓展
    整数拓展：进制二进制0b；八进制0；十进制；十六进制0x 十进制转二进制，将正的十进制除以二，得到商后再除以二，直到商为1或0时，然后各部余数填1，整数填0，然后倒着写出来，最后高位补零一个正的二进制的数转为负的只需要将该数的二进制码取反然后+1（补码）即可浮点拓展：浮点数一般都会存在舍入误差，所以......
  • 数据类型
    强类型语言要求变量的使用要严格符合规定，所有变量都必需都先定义后才能使用Java的数据类型分两大类一.基本类型：1.数值类型：整数类型byte(-128~127)占一个字节范围；short(-32768~32767)占两个字节范围；int(-2147483648~2147483647)占四个字节范围；long(-9223372036854775808~9223372036......
  • Day10 数据类型扩展及面试题讲解
    publicclassDemo03{publicstaticvoidmain(String[]args){//整数扩展：进制二进制0b十进制八进制00十六进制0xinti=10;inti2=010;//八进制0inti3=0x10;//十六进制0x0~9A~F16System.out.println(i);......
  • chap2 数据类型和操作
    Chap2数据类型和操作1.数据类型-整数int-浮点数float-布尔值bool(trueorfalse)-类型type```print(type(2.2))```输出：floatprint(type(2<2.2))输出：boolprint(type(2))输出：intprint(type(type(42)))输出：type-字符串str-列表List-元组Tuple-集合Set-字典dict或......
  • 笔记·数据类型与类型转换
    笔记·数据类型与类型转换数据类型Number（数字）python中的数字分为以下四种类型int（整数）：python中的int对应C语言中的长整型float（浮点数）：小数bool（布尔类型）：int的子类型，其中False==0True==1complex(复数)：由实数部分与虚数部分构成，可表示为complex(a,b)，其中a代表实部，b代表虚部......
  • 11.24-task3数据类型
    数据类型与操作基本类型整型int浮点数float布尔值bool(tureorfalse)类型Typetype的use:类型的类型就是类型。。。还有一些更多类型。。。常用内置常数python中是内置了一些常量的-常用内置运算符andornot类似于c语言的&&||!=运算顺序为not>and>......
  • 数据类型和操作
    数据类型和操作常用内置类型整数int浮点数float布尔值bool类型type字符串****str列表****list元组****tuple用数组array集合****set字典****dict(映射，map)复数complex函数function模块moduleeg:print(type(2))<class'int'>print(t......

赞助商

阅读排行

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

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

Copyright © 2020-2023 IPS99 版权所有 IPS99