python(六)——基本数据类型介绍

1.数字整形

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

　　1>字符串转换为数字

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

输出：

　　<class 'str'> 123
　　<class 'int'> 123

s1 = ""
s2 = "a"
print(type(s1),s1)
b = int(s1,base=2)#二进制
c = int(s2,base=16)#十六进制
print(type(b),b)
print(type(c),c)

输出：

　　<class 'str'> 0011
　　<class 'int'> 3
　　<class 'int'> 10

　　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) #
# 以什么什么结尾或开始,返回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) #

# 格式化，将字符串中的占位符替换为指定的值
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\temail\tpassword\nAliex\taliex@q.com\t123456"
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

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

s8 = 'fjdhf\tdhfds'
s9 = s8.isprintable()
print(s9)

True

join(seq)

　　以指定字符串作为分隔符，将 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

strip()

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

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

maketrans()

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

test = 'aeiou'
test1 = ''
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 in v:
    print(item)
for item in v1:
    print(item)
for item in v2:
    print(item)

test = input('>>>')
for item in range(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 in li:
    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] = ['', '', '']    # 修改
li[2:4] = ['PYTHON', 'LINUX']   # 一次修改多个
del li[1]   # 删除
del li[3:5]
for item in li:
    print(item)
print(li)

# 操作
print(li[0][1])
# 字符串转换列表
s = 'shffhfjdfe'
l = list(s)
print(l)

# 列表转字符串
# 需要自己写for循环实现：既有数字又有字符串
new_s = ''
for i in li:
    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 in test:
    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, ''])
print(v)    # {'999': None, 123: None, 'k1': None}
v = dict.fromkeys(['k1', 123, ''], 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'}
a
{1: 'a', 2: 'b'}
1
2
a
b
(1, 'a')
(2, 'b')
{'999': None, 123: None, 'k1': None}
{'999': 1200, 123: 1200, 'k1': 1200}
v1
v1
{'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', 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 in python_1:
    if i in linux_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_s
print(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_s
print(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_s
print(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() 方法用于修改当前集合，可以添加新的元素或集合到当前集合中，如果添加的元素在集合中已存在，则该元素只会出现一次，重复的会忽略
x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
x.update(y)
print(x)    # {'banana', 'cherry', 'google', 'apple', 'runoob'}

# 不可变集合
s = frozenset('hello')
print(s)