pythonitem类型-python(六)——基本数据类型介绍-优快云博客

1.数字整形

python3不管数字有多大都是int型，没有long类型

1>字符串转换为数字

s1 = "123"

print(type(s1)，s1)

b=int(s1)#不加base默认转换为十进制print(type(b),b)

b+= 1000

输出：

123

s1 = "0011"s2= "a"

print(type(s1),s1)

b= int(s1,base=2)#二进制

c= int(s2,base=16)#十六进制print(type(b),b)print(type(c),c)

输出：

0011

2>-bit_length()方法

age = 7

#7 111#3 11#1 01#当前数字的二进制至少用n位表示

r =age.bit_length()print(r)# 3

2.字符串

str

#!/usr/bin/env python#-*- coding:utf-8 -*-

test= "helLo"v= test.capitalize() #首字母大写

print(v) #Hello

v1 = test.casefold() #所有变小写，更牛逼

print(v1) #hello

v2 = test.lower() #所有变小写

print(v2) #hello

#设置宽度，并将内容居中#20 代指总长度#* 空白未知填充，一个字符，可有可无

v3 = test.center(20,"*")print(v3) #*******helLo********

#去字符串中寻找子序列出现的次数

v4 = test.count("l",4)print(v4) #0#以什么什么结尾或开始,返回bool

v5 = test.endswith("lo")

v6= test.startswith("h")print(v5)print(v6)#从开始往后找，找到第一个之后，获取其位置

test1 = "hellohello"v7= test1.find("oh", 4, 6) #大于等于4，小于6

print(v7) #4

#格式化，将字符串中的占位符替换为指定的值

test2 = "i am {name}, age {a}"

print(test2) #"i am {name}, age {a}"

v8 = test2.format(name="Alex",a=18)print(v8) #i am Alex, age 18

test3= "i am {0}, age {1}"

print(test3) #"i am {0}, age {1}"

v9 = test3.format("Alex",18)print(v9) #i am Alex, age 18

v10= test2.format_map({"name":"Alex","a":18})print(v10) #i am Alex, age 18

v11= test3.index("am")print(v11)#判断字符串是否只包含数字和字母

v12 =test2.isalnum()print(v12) #False

s = "username email password Aliex aliex@q.com 123456"s1= s.expandtabs(20);#把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。

print(s1)

输出：

username email password

Aliex aliex@q.com 123456

s2 = "②"s4= s2.isdigit() #true

s5 = s2.isdecimal()#flase

print(s4,s5)

isprintable

是否存在不可显示的字符， = 制表符

s8 = "fjdhf dhfds"s9=s8.isprintable()print(s9)

True

以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

test = "HELLO"t= "_"v=t.join(test)print(v)

输出：H_E_L_L_O

ljust，rjust

test = "alex"v= test.ljust(20,"*")print(v) #alex****************

v2= test.rjust(20,"#")print(v2) ################alex

截掉字符串的空格或指定字符（，也可以）。

test = "alex"v1=test.lstrip() # 去掉左边的

v2=test.rstrip() # 去掉右边的

v3=test.strip() # 去掉左右两边的print(v1,v2,v3) #alex alex alex

创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

test = "aeiou"test1= "12345"m=str.maketrans(test,test1)

v= "ahuwfeofjivuoiewsjnaeiou"new_v=v.translate(m)print(new_v)

输出：1h5wf24fj3v5432wsjn12345

test = "testtysusnhfhjsl"v1= test.partition("s")

v2= test.rpartition("s")print(v1,v2)

输出：

("te", "s", "ttysusnhfhjsl") ("testtysusnhfhj", "s", "l")

test = "testtysusnhfhjsl"

v3 = test.split("s",2)print(v3)

输出：["te", "tty", "usnhfhjsl"]

字符串一旦创建，不可修改

一旦修改或者拼接，都会造成重新生成字符串

range

#帮助创建连续的数字

v = range(100) #0, 1, 2, 3...

v1 = range(0, 100) #0, 1, 2, 3...

v2 = range(0, 100, 5) #0, 5, 10, 15...

for item inv:print(item)for item inv1:print(item)for item inv2:print(item)

test = input(">>>")for item inrange(len(test)):print(item,test[item])

3.列表

list　　# 类

li = [1, 12, 9, "age", "alex"]

中括号括起来，“，”分割每个元素，列表中的元素可以是数字，字符串...

集合内部可以放置任何东西

# 索引取值

print(li[3])

# 切片

print(li[1:3])

#!/usr/bin/env python#-*- coding:utf-8 -*-

li= ["hello", "world", "python", "linux", ["other", "thing"], "haha"]#列表可以修改，内部是以链表形式实现

li[0] = [11, 22, 33] #修改

li[2:4] = ["PYTHON", "LINUX"] #一次修改多个

del li[1] #删除

del li[3:5]for item inli:print(item)print(li)

输出：

[11, 22, 33]

PYTHON

LINUX

[[11, 22, 33], "PYTHON", "LINUX"]

#!/usr/bin/env python#-*- coding:utf-8 -*-

li= ["hello", "world", "python", "linux", ["other", "thing"], "haha"]#列表可以修改，内部是以链表形式实现

li[0] = ["11", "22", "33"] #修改

li[2:4] = ["PYTHON", "LINUX"] #一次修改多个

del li[1] #删除

del li[3:5]for item inli:print(item)print(li)#操作

print(li[0][1])#字符串转换列表

s = "shffhfjdfe"l=list(s)print(l)#列表转字符串#需要自己写for循环实现：既有数字又有字符串

new_s = ""

for i inli:

new_s+=str(i)print(new_s)#直接使用join方法：只有字符串

lii = ["hello", "abcd", "hsgdh"]

v= "".join(lii)print(v)#append 方法#在原来值后面追加

lii.append("hhhhh")print(lii) #["hello", "abcd", "hsgdh", "hhhhh"]

#clear 方法清空列表

lii.clear()print(lii)#拷贝

liii = ["hello", "abcd", "hsgdh", "hello"]

v= liii.copy() #浅拷贝

print(v)#count 方法计算元素出现的次数

c = liii.count("hello")print(c)#extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。#参数是可迭代对象

liii.extend(["abcd", "efgh"]) #["hello", "abcd", "hsgdh", "hello", "abcd", "efgh"]

liii.append(["abcd", "efgh"]) #["hello", "abcd", "hsgdh", "hello", "abcd", "efgh", ["abcd", "efgh"]]

liii.extend("bbb") #["hello", "abcd", "hsgdh", "hello", "abcd", "efgh", ["abcd", "efgh"], "b", "b", "b"]

print(liii)#insert() 在指定索引位置插入元素

li2 = [11, 22, 33, 44]

li2.insert(0,99)print(li2)#pop() 删除某个值（可以指定索引，默认删除最后一个），并获取删除的值

v = li2.pop(1)print(li2)print(v)#remove（）删除列表中的指定值

li2.remove(33)print(li2)#reverse() 将当前列表进行反转

li2.reverse()print(li2)#sort() 排序

li2.sort() #从小到大

li2.sort(reverse=True) #从大到小

print(li2)

4.元祖

tuple

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

#!/usr/bin/env python#-*- coding:utf-8 -*-

#tuple 元组,一级不可修改，增加或删除#一般写元组的时候，推荐在最后加入一个“，”

test = ("hello", "world",)print(test)#可以被for 循环，可迭代对象

for i intest:print(i)#字符串，列表，元组可以相互转换

li =list(test)print(li)

v= "_".join(test)print(v) #hello_world

#元组的一级元素不可修改，二级等元素可以修改

tu = (111, "abc", [33, 44])

tu[2][1] = 99 #二级元素是列表，可以修改

print(tu)

输出：

("hello", "world")

hello

world

["hello", "world"]

hello_world

(111, "abc", [33, 99])

5.字典

dict

#字典是另一种可变容器模型，且可存储任意类型对象。#字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中

info = {"k1": "v1", #键值对

"k2": "v2"}print(info)#字典是无序的#值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

dict1 = {1: "a", 2: "b"}print(dict1[1])#del dict1[1]

print(dict1)for item in dict1.keys(): #键

print(item)for item in dict1.values(): #值

print(item)for item in dict1.items(): #键值对

print(item)#根据序列，创建字典，并指定统一的值

v = dict.fromkeys(["k1", 123, "999"])print(v) #{"999": None, 123: None, "k1": None}

v = dict.fromkeys(["k1", 123, "999"], 1200)print(v) #{"k1": 1200, 123: 1200, "999": 1200}

#get() 根据key获取值，当key不存在时，默认为None或指定

v = info.get("k1", 111)print(v)#pop() 删除

v = info.pop("k1")print(v)#popitem() 随机删除

info = {"k1": "v1", #键值对

"k2": "v2"}

v=info.popitem()print(info, v)#setdefault() 设置值，若已存在，则不设置，获取当前key对应的值#若不存在，设置

v = info.setdefault("k3", "v3")print(info, v) #{"k1": "v1", "k3": "v3"} v3

#update

info.update({"k1": "v111", "k2": "v222"})

info.update(k4="v4")print(info)

输出：

{"k2": "v2", "k1": "v1"}

{1: "a", 2: "b"}

(1, "a")

(2, "b")

{"999": None, 123: None, "k1": None}

{"999": 1200, 123: 1200, "k1": 1200}

{"k1": "v1"} ("k2", "v2")

{"k3": "v3", "k1": "v1"} v3

{"k4": "v4", "k3": "v3", "k2": "v222", "k1": "v111"}

6.布尔值

bool

可变不可变类型：

可变：列表，字典

不可变：字符串，数字，元组

访问顺序：

1.顺序访问：字符串，列表，元组

2.映射：字典

3.直接访问：数字

存放元素个数：

容器类型：列表，元组，字典

原子：数字，字符串

7.集合

集合（set）是一个无序的不重复元素序列。

1.不同元素组成

2.无序

3.集合中元素必须是不可变类型

s = set("hello")print(s)

s= set(["ab", "ab", "sb"])print(s)#add

a = {1, 2, 3}

a.add("3") #{"3", 1, 2, 3}

a.add(3)print(a)#清空

a.clear()print(a) #set()

#pop随机删除

a = {1, 2, 3, "s"}

a.pop()#{1, 2, "s"}

print(a)#remove 可以指定删除元素,若删除元素不存在则报错

a = {1, 2, 3, "s"}

a.remove(2) #{"s", 1, 3}#a.remove(5) error

print(a)#discard 可以指定删除元素，若删除元素不存在不报错

a = {1, 2, 3, "s"}

a.discard(2) #{1, 3, "s"}

a.discard("cd")print(a)#若无集合，求下面列表的交集

python_1 = ["a", "b", "c"]

linux_1= ["a", "b", "d"]

python_and_linux=[]for i inpython_1:if i inlinux_1:

python_and_linux.append(i)print(python_and_linux) #["a", "b"]

#集合关系测试

python_2 = ["a", "b", "c"]

linux_2= ["a", "b", "d"]

python_s=set(python_2)

linux_s=set(linux_2)#并集

python_and_linux_s = python_s |linux_sprint(python_and_linux_s) #{"d", "c", "a", "b"}

print(python_s.union(linux_s)) #{"b", "a", "c", "d"}#交叉补集

python_and_linux_s = python_s ^linux_sprint(python_and_linux_s) #{"c", "d"}

print(python_s.symmetric_difference(linux_s)) #{"c", "d"}#差集

print(python_s.difference(linux_s)) #{"c"}

print(python_s - linux_s) #{"c"}

print(linux_s - python_s) #{"d"}#交集

python_and_linux_s = python_s &linux_sprint(python_and_linux_s) #{"a", "b"}

python_and_linux_s=python_s.intersection(linux_s)print(python_and_linux_s) #{"a", "b"}

python_s.difference_update(linux_s)print(python_s) #{"c"}

#isdisjoint() 方法用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

x = {"apple", "banana", "cherry"}

y= {"google", "runoob", "facebook"}

z=x.isdisjoint(y)print(z) #True

#issubset() 方法用于判断集合的所有元素是否都包含在指定集合中，如果是则返回 True，否则返回 False。

x = {"a", "b", "c"}

y= {"f", "e", "d", "c", "b", "a"}

z=x.issubset(y)print(z) #True

#update() 方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略