python_fullstack基础(三)-基本数据类型

最新推荐文章于 2020-12-10 20:37:18 发布

ElijahYang

最新推荐文章于 2020-12-10 20:37:18 发布

阅读量538

点赞数 2

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/dragonyangang/article/details/78834754

版权

python 专栏收录该内容

33 篇文章 2 订阅

订阅专栏

python_fullstack基础(三)

1、int(数字类型)

1.1 介绍

表示数字0 - 9

1.2 常用方法

输出数字的位长：bit_length()

# 因为十进制数18的二进制为10010，即bin(18) = 10010，所以18的位长是5

i = 18
print(i.bit_length())

>>>5

2、boolen(布尔类型)

2.1 介绍

布尔值只有True和False，同时True对应二进制中1，False对应二进制中0

# 其他数据类型与布尔类型的相互转换
int ——> boolen
    非0数值的布尔值：True
    数字0的布尔值：False

str——> boolen
    非空字符串的布尔值：True
    空字符串的布尔值：False

boolen——>int
    True: 1
    False: 0

3、string(字符串类型)

3.1 介绍

在单引号、双引号、三引号内，由一串字符组成的叫字符串

3.2 字符串的索引与切片

字符串索引

s = 'ABCDEFGHIJK'
print(s[0])
>>> 'A'

print(s[2])
>>> 'C'

print(s[-1])
>>>'K'

print(s[-2])
>>> 'J'

字符串切片：顾头不顾尾

s = 'ABCDEFGHIJK'
print(s[0:4])
>>>'ABCD'

print(s[0:-1])
>>>'ABCDEFGHIJ'

print(s[:])
>>>'ABCDEFGHIJK'

print(s[0:])
>>>'ABCDEFGHIJK'

print(s[0:0])
>>>

s = 'ABCDEFGHIJK'  # s[首:尾:步长]
print(s[0:5:2])
>>>'ACE'

print(s[4:0:-1])
>>>'EDCB'

print(s[3::-1])
>>>'DCBA'

print(s[3::-2])
>>>'DB'

print(s[-1::-1])
>>>'KJIHGFEDCBA'

print(s[::-1])
>>>'KJIHGFEDCBA'

3.3 常用方法

s = 'PytHOn'

# captalize,swapcase,title
print(s.capitalize())
>>>'Python'

print(s.swapcase())
>>>'pYThoN'

s1 = '-python*fullstack@s9'
print(s1.title())
>>>'-Python*Fullstack@S9'

# upper、lower
print(s.upper())
>>>'PYTHON'

print(s.lower())
>>>'python'

# center、expandtabs
print(s.center(20, '*'))
>>>'*******PytHOn*******'

# 在\t前面不全8或8的倍数个空格，如果有字符的话字符先顶头
s2 = 'python\tfullstack'
print(s2.expandtabs())
>>>'python  fullstack'

# 公共方法len()
print(len(s))
>>>6

# startswith、endswith
print(s.startswith('Py'))
>>>True

print(s.startswith('Py', 1, 4))
>>>False

print(s.endswith('On'))
>>>True

print(s.endswith('On'), 4)
>>>True

# find、index
print(s.find('H'))
>>>3

print(s.index('H'))
>>>3

# strip rstrip lstrip
s3 = '  python '
print(s3.strip())
>>>'python'

s4 = ' @python*@'
print(s4.strip('*@'))
>>>' @python'

print(s.rstrip())
>>>' @python'

print(s.lstrip())
>>>' @python*@'

# replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','python',1))

# is系列
name='python666'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成
print(name.isalnum()) #是否全是字母和数字，并至少有一个字符 
print(name.isspace()) #是否全是空白字符，并至少有一个字符 

# count
s5 = 'life is short we use python'
print(s5.count('s'))
>>>3

s6 = 'lifeisshortweusepython'
print(s6.split('s'))
>>>['lifei','','hortweu','epython']

# format 三种用法
s7 = '大家好我叫{}，我今年{}，我喜欢{}，再说一遍我叫{}'
print(s7.format('ELijah', 26, 'coding', 'Elijah'))
>>>大家好我叫ELijah，我今年26，我喜欢coding，再说一遍我叫Elijah

s8 = '大家好我叫{0}，我今年{1}，我喜欢{2}，再说一遍我叫{0}'
print(s8.format('ELijah', 26, 'coding'))
>>>大家好我叫ELijah，我今年26，我喜欢coding，再说一遍我叫Elijah

s9 = '大家好我叫{name}，我今年{age}，我喜欢{hobby}，再说一遍我叫{name}'
print(s9.format(hobby='coding', name='ELijah', age=26))
>>>大家好我叫ELijah，我今年26，我喜欢coding，再说一遍我叫Elijah

4、list(列表类型)

4.1 介绍

列表是我们最以后最常用的数据类型之一，通过列表可以对数据实现最方便的存储、修改等操作。

4.2 常用方法

# list列表常用方法

# 增
# 在列表末尾添加元素
lst = ['C','Java','C++','Ruby','PHP']
lst.append('Python')
print(lst)
>>> ['C','Java','C++','Ruby','PHP','Python']

# 在指定索引前插入元素
lst = ['C','Java','C++','Ruby','PHP']
lst.insert(3,'Python')
print(lst)
>>> ['C','Java','C++','Python','Ruby','PHP']

# 以迭代的方式在列表末尾添加元素
lst = ['C','Java','C++','Ruby','PHP']
lst.extend('Python')
print(lst)
>>> ['C','Java','C++','Python','Ruby','PHP','P','y','t','h','o','n']

# 删 
# 删除指定索引的元素，默认无索引则删除最后一个元素
lst = ['C','Java','C++','Ruby','PHP']
lst.pop(3)
print(lst)
>>> ['C','Java','C++','PHP']
# pop()有返回值，返回删除掉的元素
print(lst.pop(3))
>>> 'Ruby'

lst = ['C','Java','C++','Ruby','PHP']
lst.pop()
print(lst)
>>> ['C','Java','C++','Ruby']
# pop()有返回值，返回删除掉的元素
print(lst.pop())
>>> 'PHP'

# 删除指定元素
lst = ['C','Java','C++','Ruby','PHP']
lst.remove('Ruby')
print(lst)
>>> ['C','Java','C++','PHP']

# 清空列表所有元素
lst = ['C','Java','C++','Ruby','PHP']
lst.clear()
print(lst)
>>> []

# 删除列表
lst = ['C','Java','C++','Ruby','PHP']
del lst
print(lst)
>>> Traceback (most recent call last):
      File "D:practice.py", line 5, in <module>
        print(lst)
    NameError: name 'lst' is not defined

# 删除列表指定索引元素
lst = ['C','Java','C++','Ruby','PHP']
del lst[3:]
print(lst)
>>> ['C','Java','C++']

# 改
# 直接指定元素索引并赋予新值进行修改
lst = ['C','Java','C++','Ruby','PHP']
lst[3] = 'Python'
print(lst)
>>> ['C','Java','C++','Python','PHP']

# 利用切片进行迭代修改
lst = ['C','Java','C++','Ruby','PHP']
lst[3:] = 'Python'
print(lst)
>>> ['C','Java','C++','P','y','t','h','o','n']

# 查
# 通过循环迭代查询列表中元素
lst = ['C','Java','C++','Ruby','PHP']
for i in lst:
    print(i)

# 切片查询列表中一部分元素
lst = ['C','Java','C++','Ruby','PHP']
print(lst[0:3])
>>> ['C','Java','C++']

#---------------------------------------

# 列表排序
# 正序排序
lst = [4,3,2,5,7,8,9,1,6,0]
lst.sort()
print(lst)
>>> [0,1,2,3,4,5,6,7,8,9]

# 倒序排序
lst = [4,3,2,5,7,8,9,1,6,0]
lst.sort(reverse=True)
print(lst)
>>> [9,8,7,6,5,4,3,2,1,0]

# 翻转
lst = [4,3,2,5,7,8,9,1,6,0]
lst.reverse()
print(lst)
>>> [0,6,1,9,8,7,5,2,3,4]

#---------------------------------------

# 列表的嵌套
lst = ['C','Java','C++','Python','Ruby','PHP',['HTML','GO','R','Objective-C']]
# 需求：将"HTML"改为"JavaScript"
lst[-1][0] = 'JavaScript'
print(lst)
# 需求：将"PHP"改为"php"
lst[5] = lst[5].lower()
print(lst)

#---------------------------------------

# join()方法
# S.join():其中S是字符串连接符，join中参数必须是可迭代对象，join()方法输出可迭代对象的每一个元素，并用连接符将每一个元素连接
s = 'ilovepython'
l = ['C','Java','C++','Ruby','PHP','Python']
print('_'.join(s))
>>> 'i_l_o_v_e_p_y_t_h_o_n'
print('_'.join(l))
>>> 'C_Java_C++_Ruby_PHP_Python'

4.3 公共方法

# 公共方法
# 统计元素长度
s = 'ilovepython'
l = ['C','Java','C++','Ruby','PHP','Python','C','JAVA']
print(len(s))
>>> 11
print(len(l))
>>> 8

# 统计元素出现的次数
s = 'ilovepython'
l = ['C','Java','C++','Ruby','PHP','Python','C','JAVA']
print(s.count('o'))
>>> 2
print(l.count('C'))
>>> 2

# 输出指定元素的索引值
s = 'ilovepython'
l = ['C','Java','C++','Ruby','PHP','Python','C','JAVA']
print(l.index('Java'))
>>> 1
print(s.index('e'))
>>> 4

4.4 ★★★重要方法

# string <——> list : 字符串与列表的相互转换
# string ——> list : split()

s = 'i_l_o_v_e_p_y_t_h_o_n'
print(s.split('_'))
>>> ['i', 'l', 'o', 'v', 'e', 'p', 'y', 't', 'h', 'o', 'n']

# list ——> string : join()
l = ['C','Java','C++','Ruby','PHP','Python']
print(''.join(l))
>>> CJavaC++RubyPHPPython

4.4.1 range()方法

# range:相当于都是数字的列表 [0,1,2,3,4.....,99]
# range(起始值，终止值)
for i in range(0,100):
    print(i)

# 默认起始值不写默认为0
for i in range(100):
    print(i)

# 同索引一样，range也可以加步长,加步长的话默认的0起始值就不可以省略
for i in range(0,100,2):
    print(i)

for i in range(100,0,-2):
    print(i)

4.4.2 enumerate()方法

# 枚举。对于一个可迭代的(iterable)/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

lst = ['python','java','c','ruby','Go']
for i in enumerate(lst):
    print(i)

>>> (0, 'python')
>>> (1, 'java')
>>> (2, 'c')
>>> (3, 'ruby')
>>> (4, 'Go')

for index, name in enumerate(lst, 1):
    print(index, name)

>>> 1 python
>>> 2 java
>>> 3 c
>>> 4 ruby
>>> 5 Go

for index, name in enumerate(lst, 100):  # 起始位置默认是0，可更改
    print(index, name)　

>>> 100 python
>>> 101 java
>>> 102 c
>>> 103 ruby
>>> 104 Go

4.4.3 ★深浅拷贝 copy()、deepcopy()

①原理讲解及测试

# 普通赋值运算
lst_1 = ['Python','Java',['Ruby','PHP','C++']]
lst_2 =lst_1 # lst_2 = lst_1[:] 同理

print(lst_1)
print(id(lst_1))
print('*'*10)
print(lst_2)
print(id(lst_2))

>>> ['Python','Java',['Ruby','PHP','C++']]
>>> 18623368
>>> **********
>>> ['Python','Java',['Ruby','PHP','C++']]
>>> 18623368

# 浅copy()方法：第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。
lst_1 = ['Python','Java',['Ruby','PHP','C++']]
lst_2 =lst_1.copy() # lst_2 = lst_1[:] 同理

lst_1[2].append('new_lanuage')
print(lst_1,id(lst_1))
print('*'*10)
print(lst_2,id(lst_2))

>>> ['Python', 'Java', ['Ruby', 'PHP', 'C++', 'new_lanuage']] 12001800
>>> **********
>>> ['Python', 'Java', ['Ruby', 'PHP', 'C++', 'new_lanuage']] 12015048

# 深copy()方法：对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。
import copy
lst_1 = ['Python','Java',['Ruby','PHP','C++']]
lst_2 = copy.deepcopy(lst_1)

lst_1[2].append('new_lanuage')
print(lst_1,id(lst_1))
print('*'*10)
print(lst_2,id(lst_2))

>>> ['Python', 'Java', ['Ruby', 'PHP', 'C++', 'new_lanuage']] 12533000
>>> **********
>>> ['Python', 'Java', ['Ruby', 'PHP', 'C++']] 12533512

这里写图片描述

5、tuple(元组类型)

5.1 介绍

Python的元组与列表类似，同样可通过索引访问，支持异构，任意嵌套。不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

5.2 常用方法

Tuple与List方法相同，不同在于元组不能更改

6、dict(字典类型)

6.1 介绍

6.1.1 字典介绍

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

6.1.2数据类型划分：可变数据类型、不可变数据类型

不可变数据类型：元组、布尔值、数值、字符串 ——> 不可变数据类型又称为可哈希
可变数据类型：列表、字典、集合 ——>不可哈希

6.1.3 字典的特性

字典dict的key必须是不可变数据类型：元组、布尔值、数值、字符串
字典dict的value可以是任意数据类型
字典dict的优点：
- 二分查找查询
- ②存储大量的关系型数据
字典的特点：
- 无序的——>无索引（python3.5及以前版本）

6.2 常用方法

dic = {'age': 26, 'name': 'yang', 'sex': 'male'}

# --------------------------------------------------------------------------
# 增 - 2种
dic['height'] = 180 # 如果没有键，则增加
>>> {'age': 26, 'name': 'yang', 'sex': 'male','height':180}
dic['age'] = 18 # 如果有键，则覆盖
>>> {'age': 18, 'name': 'yang', 'sex': 'male'}

dic.setdefault('height') # 如果没有键，则增加，且如果不写值vlaue，则默认None
>>> {'age': 26, 'name': 'yang', 'sex': 'male','height':None}
dic.setdefault('height', 185) # 如果没有键，则增加
>>> {'age': 26, 'name': 'yang', 'sex': 'male','height':185}
dic.setdefault('age', 185) # 如果有键，不覆盖
>>>{'age': 26, 'name': 'yang', 'sex': 'male'}

# --------------------------------------------------------------------------

# 删 - 4种
# ①
dic.pop('name1','No KEY') # 如果有没键，不报错，返回值会返回后面的参数文本
>>> print(dic.pop('name1','No KEY'))
>>> 'No KEY'
>>> print(dic)
>>> {'name': 'yang', 'sex': 'male', 'age': 26}

dic.pop('age') # 如果有键,则删除对应的键值对；返回值会返回删除掉的值value
>>> print(dic.pop('age'))
>>> 26
print(dic)
>>> {'sex': 'male', 'name': 'yang'}

# ②
dic.popitem() # 随机删除字典中的一组键值对
>>> {'name': 'yang', 'sex': 'male'}

# ③
del dic['height'] # 如果没有键，则报错
>>> Traceback (most recent call last):
      File "D:/python_fullstack_s9/day5/day5_课堂内容总结.py", line 31, in <module>
        del dic['height'] # 如果没有键，则报错
    KeyError: 'height'
del dic['age'] # 如果有键，则删除对应的键值对
>>> {'name': 'yang', 'sex': 'male'}

# ④
dic.clear() # 清空字典
>>> {}

# --------------------------------------------------------------------------

# 改 - 2种
# ①
dic['height'] = 185 # 如果没有键，则增加
>>> {'height': 185, 'age': 26, 'sex': 'male', 'name': 'yang'}

dic['age'] = 18 # 如果有键，则修改
>>> {'sex': 'male', 'name': 'yang', 'age': 18}

# ②
dic_new = {'lanuage':'PYTHON','addr':'昌平'}
dic.update(dic_new) # update(dict)，update的参数必须是键值对，将dic_new所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic中
>>> {'sex': 'male', 'addr': '昌平', 'lanuage': 'PYTHON', 'name': 'yang', 'age': 26}

# --------------------------------------------------------------------------

# 查 - 5种
# ①
dic.keys() # 获取字典的键，返回dict.keys的数据类型，相当于list

默认打印字典的键
for i in dic1:
    print(i)

for i in dic1.keys():
    print(i)

# ②
dic.values() # 获取字典的值，返回dict.values的数据类型，相当于list

默认打印字典的值
for i in dic1.values():
    print(i)

# ③
dic.items() # 获取字典的键和值，返回由keys和values组成的元组

默认打印字典的键值
for i in dic1.items():
    print(i)

for keys,values in dic1.items():
    print(keys,values)

# ④
dic.get('height','No KEY') # 如果没有键，则返回值为后面的参数文本
print(dic.get('height','No KEY'))
>>> No KEY

dic.get('age','No KEY') # 如果有键，则返回值为对应键的值
print(dic.get('age','No KEY'))
>>> 26

# ⑤
print(dic['height']) # 如果有没键，则报错
>>> Traceback (most recent call last):
      File "D:/python_fullstack_s9/day5/day5_课堂内容总结.py", line 79, in <module>
        print(dic['height']) # 如果有没键，则报错
    KeyError: 'height'

print(dic['age']) # 如果有键，则返回键对应的值
>>> 26

# --------------------------------------------------------------------------
# 字典的嵌套
dic = {
    'name':['a','b','c'],
    'age':43,
    'addr':{
        '1':1,
        '2':2,
    }
}

# 需求：在addr中加入'3':3这个键值对
dic['addr']['3'] = 3
print(dic)

7、set(集合类型)

7.1 介绍

7.1.1 集合介绍

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
1. 去重，把一个列表变成集合，就自动去重了。
2. 关系测试，测试两组数据之前的交集、差集、并集等关系。

7.2 常用方法

# 集合
# 增 - 2种
set1 = {'a', 'b', 'c', 'd'}
set1.add('e')
print(set1)
>>> {'a', 'c', 'd', 'e', 'b'}

set_new = {'A','B','C','D'}
set1.update(set_new)
print(set1)
>>> {'b', 'C', 'B', 'c', 'a', 'A', 'D', 'd'}

# 删 - 4种
set1 = {'a', 'b', 'c', 'd'}
set1.pop()
print(set1)
>>> {'d', 'c', 'b'}

set1.remove('c')
print(set1)
>>> {'d', 'b', 'a'}

set1.clear()
print(set1)
>>> set()

del set1
print(set1)
>>>Traceback (most recent call last):
      File "D:/python_fullstack_s9/day7/practice.py", line 160, in <module>
        print(set1)
    NameError: name 'set1' is not defined

# 查 - 6种
set1 = {'a', 'b', 'c', 'd'}

for i in set1:
    print(i)
>>> d
>>> a
>>> c
>>> b

# ①交集
set1 = {'a', 'b', 'c', 'd', '1', '4'}
set2 = {'1', '2', '3', '4', 'b', 'c'}
print(set1 & set2)
>>> {'c', '4', '1', 'b'}
print(set1.intersection(set2))
>>> {'c', '4', '1', 'b'}

# ②反交集
set1 = {'a', 'b', 'c', 'd', '1', '4'}
set2 = {'1', '2', '3', '4', 'b', 'c'}
print(set1 ^ set2)
>>> {'d', '2', 'a', '3'}
print(set1.symmetric_difference(set2))
>>> {'d', '2', 'a', '3'}

# ③并集
set1 = {'a', 'b', 'c', 'd', '1', '4'}
set2 = {'1', '2', '3', '4', 'b', 'c'}
print(set1 | set2)
>>> {'1', 'b', '2', '3', 'c', 'd', '4', 'a'}
print(set1.union(set2))
>>> {'1', 'b', '2', '3', 'c', 'd', '4', 'a'}

# ④差集
set1 = {'a', 'b', 'c', 'd', '1', '4'}
set2 = {'1', '2', '3', '4', 'b', 'c'}
print(set1 - set2)
>>> {'d', 'a'}
print(set1.difference(set2))
>>> {'d', 'a'}

print(set2 - set1)
>>> {'2', '3'}
print(set2.difference(set1))
>>> {'2', '3'}

# ⑤子集与超集
set1 = {'A','B','C','a','b','c'}
set2 = {'A','B','C'}
print(set2 < set1)
>>> True
print(set2.issubset(set1))
>>> True

print(set1 > set2)
>>> True
print(set1.issuperset(set2))
>>> True

# ------------------------------------------------------------

# 不可变集合
set_frozen = frozenset({'A', 'B', 'C'})
print(set_frozen)
>>> frozenset({'C', 'B', 'A'})

ElijahYang

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
python_fullstack基础(三)-基本数据类型

python_fullstack基础(三)1、int(数字类型)1.1 介绍表示数字0 - 91.2 常用方法输出数字的位长：bit_length()# 因为十进制数18的二进制为10010，即bin(18) = 10010，所以18的位长是5i = 18print(i.bit_length())>>>52、boolen(布尔类型)
复制链接

扫一扫