python基础（数据类型，列表，字典，字符串，元祖，集合）

其他 2020-10-26 09:30:54 阅读次数: 0

python第二节课

数据类型

整数型、浮点、布尔值

  • 整型：通常称为整数，是整数或者负数，不带小数点
  • 浮点型：浮点型由整数部分与小数部分组成
  • 布尔值，真，假，1,0

进制

  • 二进制 01

  • 八进制01234567

  • 十进制0123456789

  • 十六进制0123456789ABCDEF

  • python进制转换

bin(100)# 十进制转换二进制
Out[134]: '0b1100100' 
oct(100) # 十进制转换八进制
Out[135]: '0o144'
hex(100) # 十进制转换十六进制
Out[136]: '0x64'



int('0b1100100',2)# 二进制转换十进制
Out[137]: 100

int('0o144',8)# 二进制转换八进制
Out[138]: 100

int('0x64',16)# 二进制转换十六进制
Out[139]: 100

字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符，在python中我们通常用type（）去查看变量的类型。
例如：
a = 1
print(type(a))
结果
<class ‘int’>

a = ‘zhangsan’
print(type(a))
<class ‘str’>

常用的字符串的内置方法

更改大小写

  1. 首字母大写，其余小写
test_string = 'zhangsan'
print(test_string.capitalize())
  1. 全部大写
test_string = 'zhangsan'
print(test_string.upper())

3 全部小写

test_string = 'ZHANGSAN'
print(test_string.lower())
  1. 大小写互换
test_string = 'ZhangSan'
print(test_string.swapcase())

判断字符串中的字符类型

注意：这里*是任意字符

  • 是否以*开头
test_string = 'ZhangSan'
print(test_string.startswith('Z'))
  • 是否以*结尾
test_string = 'ZhangSan'
print(test_string.endswith('n'))
  • 是否全为字母或数字
test_string = 'ZhangSan'
print(test_string.isalnum())
  • 是否全字母
test_string = 'ZhangSan'
print(test_string.isalpha())
  • 是否全数字
test_string = '886'
print(test_string.isdigit())
  • 是否全小写
test_string = 'zhangsan'
print(test_string.islower())
  • 是否全大写
test_string = 'zhangsan'
print(test_string.isupper())
  • 判断字符是否全为空格
test_string = 'zhangsan '
print(test_string.isspace())

  •  判断首字母是否为大写

test_string = 'Zhangrunz '
print(test_string.istitle())

字符串替换

替换***为^^^

test_string = 'Zhangsan '
print(test_string.replace('Zhang','wang'))

去空格

  • 去两边空格
test_string = ' i am zhang san '
print(test_string.strip())
 i am zhang san # 没去掉之前
i am zhang san #去掉之后
  • 去左边空格
test_string = ' i am zhang san '
print(test_string.lstrip())
i am zhang san #去掉之后
 i am zhang san # 去掉之前
  • 去右边空格
test_string = ' i am zhang san       '
print(test_string.rstrip())
print(test_string)
 i am zhang san# 去掉之前
 i am zhang san     #去掉之后

用特定符连接单个字符

  1. 连接
test_string = '20200918'
print(':'.join(test_string))

2.加号

test_string = '123'
test_string2 = '456'
test_string3 = test_string + test_string2
print(test_string3)

用字符串中的特定符分割字符串

  1. 按指定字符分割字符串为数组
test_string = 'i am zhangsan'
print(test_string.split(' '))

用.split形成了列表，如果取出每个列表的元素可以用循环例如

test_string = 'i am zhangsan'
print(test_string.split(' '))
test = test_string.split(' ')
print(test[1])
i = 0
while i < len(test):
    print(test[i])
    i += 1

有一个需求，统计班里所有同学名字，并逐个打印

names = "zhangsan lisi wangmazi"
f_name = names.split(" ")

a = len(f_name)

if a == 0:
    print("请输入姓名！")
else:
    i = 0
    while i < a:
        print(f_name[i])
        i += 1

搜索

  • 统计指定的字符串出现的次数
test_string = 'i am zhangsan'
print(test_string.count('a'))

统计第一个搜索字母的位置

test_string = 'i am zhangsan'
print(test_string.find('a'))

列表

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。一般用[]表示。

列表的增删盖查、内置方法

增

  1. append（）
    append() 追加单个元素到List的尾部，只接受一个参数，参数可以是任何数据类型，被追加的元素在List中保持着原结构类型。
test_list =['zhangsan', 'lisi', 'wangmazi']
test_list.append('fengjie')
print(test_list)
  1. extend()
    extend() 将一个列表中每个元素分别添加到另一个列表中，只接受一个参数。
test_list = ['zhangsan', 'lisi', 'wangmazi']
test_list1 = ['wangjie'] 
test_list.append('fengjie')
test_list.extend(test_list1)
print(test_list)

如果这时添加以一个字符串则会把字符串分开添加

test_list = ['zhangsan', 'lisi', 'wangmazi']
test_list1 = ['wangjie'] 
test_list.append('fengjie')
test_list.extend('liulei')
print(test_list)
  1. . insert()
    insert（）将一个元素插入到列表中，第一个参数是插入的位置，第二个是放入的元素。
test_list = ['zhangsan', 'lisi', 'wangmazi']
test_list1 = ['wangjie'] 
test_list.insert(1, 'wuxiaoxiao')
print(test_list)
  1. +号
    注意：“+”是重新创建一个列表，如果两个相加的列表比较大，会很小号资源。
test_list = ['zhangsan', 'lisi', 'wangmazi']
test_list1 = ['wangjie'] 
test = test_list + test_list1
print(test)
  1. join()
    利用join()，可以将列表转换为字符串
test_list = ['zhangsan', 'lisi', 'wangmazi']
test_list1 = ['wangjie']
test = ''.join(test_list)
print(type(test)) 
print(test)

删

  1. remove()
    删除是要输入要删除的内容，不能输入索引。
test_list = ['zhangsan', 'lisi', 'wangmazi']
test_list.remove('lisi')
print(test_list)
  1. del()
test_list = ['zhangsan', 'lisi', 'wangmazi']
del test_list[0]
print(test_list)
  1. pop()
    pop()用于移除列表中的一个元素（默认最后一个元素）
test_list = ['zhangsan', 'lisi', 'wangmazi']
test_list.pop()
print(test_list)

改

insert()
insert()修改列表中的一个元素，第一个参数是替换的索引，第二个是替换的内容。

test_list = ['zhangsan', 'lisi', 'wangmazi']
test_list.insert(0, 'liufei')
print(test_list)

查

  1. in
    in 判断所查找的元素是否在列表中，是为TRUE，否为FALSE。
test_list = ['zhangsan', 'lisi', 'wangmazi']
test = 'zhangsan' in test_list
print(test)
  1. count（）
    统计指定值在列表中出现的次数
test_list = ['zhangsan', 'lisi', 'wangmazi', 'lisi']
test = test_list.count('lisi')
print(test)
  1. index（）
    查看指定值在列表中第一次出现的索引
test_list = ['zhangsan', 'lisi', 'wangmazi', 'lisi']
test = test_list.index('lisi')
print(test)

内置方法

  1. reverse() 函数用于反向列表中元素。
test_list = ['zhangsan', 'lisi', 'wangmazi', 'lisi', 'lisi']
test_list.reverse()
print(test_list)
  1. sort（）
    sort（）排序方法数字、字符串按照ASCII，中文按照unicode从小到大排序
test_list = ['a', 'b', 'd', 'c', 'e']
test_list.sort()
print(test_list)

sort（）内置函数默认是FALSE，即从小到大，当内置函数为（reverse=True）则从大到小。

test_list = ['a', 'b', 'd', 'c', 'e']
test_list.sort(reverse=True)
print(test_list)
  1. clear()
    clear（）用于清空列表。
test_list = ['1', '2', '3', '4', '5']
test = test_list.clear()
print(test)

#结果为None
  1. copy（）
    copy() 用于复制列表
test_list = ['1', '2', '3', '4', '5']
test = test_list.copy()
print(test)

# 结果为：['1', '2', '3', '4', '5']

test_list.append('d')
print(test_list)
print(test)
# 结果为
# ['1', '2', '3', '4', '5']
# ['1', '2', '3', '4', '5', 'd']
# ['1', '2', '3', '4', '5']

在这里插入图片描述首先，test_list 指向一个列表，然后把 test_list 复制了一份，赋值给 test ，由于 添加的是 第一个列表，所以第二个列表不受影响。

浅拷贝和深拷贝

复制列表，分为浅复制和深复制，浅复制有时会随着原件的变化而变化，而深复制不会。

浅复制类型：

  1. list1 = list2
list1 = [1, 2, 3, 4, [5,6]]
list2 = list1
list1[-1][0] = 7
print(list1)
print(list2)

# 结果为：
# [1, 2, 3, 4, [7, 6]]
# [1, 2, 3, 4, [7, 6]]

这样变动已经改变了我们当初为了备份的初衷。
2. 导入import
list2 = copy.copy(list1)

import copy


list1 = [1, 2, 3, 4, [5,6]]
list2 = copy.copy(list1)
print(list2)
list1[-1][0] = 7
print(list1)
print(list2)

print(id(list1[-1][0]))
print(id(list1[-1][0]))
print(id(list1))
print(id(list2))
# 结果为
# [1, 2, 3, 4, [5, 6]]
# [1, 2, 3, 4, [7, 6]]
# [1, 2, 3, 4, [7, 6]]
# 140710538617424
# 140710538617424
# 2932976013768
# 2932975931528

在这里插入图片描述

这时候我们就要进行深拷贝

import copy


list1 = [1,2,3,4]
list2 = list1

list3 = copy.deepcopy(list1)

list1.append(5)


print(list1)
print(list2)
print(list3)

元祖

元祖和列表类似，可以称为不可修改的列表，用（）就可以创建元祖，而且元祖不可修改

  • 创建一个元祖
tup1 = ('lisi',1998,[180,18])
  • 元祖创建规则`
    创建单个元素的元祖必须带,号
tup1 = ('lisi',1998,[180,18])
print(tup1)

a = 1
print(type(a))
print(type(tup1))
tup2 = (2)
print(type(tup2))
tup3 = (2,)
print(type(tup3))

字典

字典是python唯一的内置映射类型，其中的值不按顺序排列，而是储存在键下。

info={
    
    }   #定义空字典
phonebook = {
    
    
    'zhangsana':1234,
    'lisi':147258,
    'wangmazi':'789456'
    }# 创建新字典
phonebook_items = [('xiaoer','123465'), ('dianjia','147258')] 
phonebook2 = dict(phonebook_items)
print(phonebook2)
# 利用元祖和列表也能创建字典使用函数dict

字典的增删改查、内置方法

增

  • 对字典添加dict[key] = vales
phonebook['lisi'] = 456132
  • dict.setdefault(key, default=None)
  • 查找一个键，如果键不存在于字典中，将会添加键并将值设为default
phonebook = {
    
    
    'zhangsana':1234,
    'lisi':147258,
    'wangmazi':'789456'
    }

phonebook_get1 = phonebook.setdefault('lisi')
phonebook_get2 = phonebook.setdefault('wangjie', '12346')


print(phonebook_get1)
print(phonebook)


# 结果为：
#147258
# {'zhangsana': 1234, 'lisi': 147258, 'wangmazi': '789456', 'wangjie': '12346'}
  • dict.update(dict2)
    把字典dict2的键/值对更新到dict里
phonebook1 = {
    
    
    'zhangsana':1234,
    'lisi':147258,
    'wangmazi':'789456'
    }
phonebook2 = {
    
    
    'joker':1478989,
    'loop':123456789
    }
phonebook1.update(phonebook2)

print(phonebook1)


# 结果为：
#{'zhangsana': 1234, 'lisi': 147258, 'wangmazi': '789456', 'joker': 1478989, 'loop': 123456789}

删

  • dict.clear（）
    是对字典的清空，不能删除一个元素。
phonebook = {
    
    
    'zhangsana':1234,
    'lisi':147258,
    'wangmazi':'789456'
    }

print(phonebook)
phonebook.clear()
print(phonebook)

# 结果为：
# {'zhangsana': 1234, 'lisi': 147258, 'wangmazi': '789456'}
# {}
  • pop(key)
    删除字典给定键 key 所对应的值
phonebook1 = {
    
    
    'zhangsana':1234,
    'lisi':147258,
    'wangmazi':'789456'
    }

phonebook1.pop('lisi')

print(phonebook1)


# 结果为：
# {'zhangsana': 1234, 'wangmazi': '789456'}

改

  • 修改值
phonebook1 = {
    
    
    'zhangsana':1234,
    'lisi':147258,
    'wangmazi':'789456'
    }

phonebook1['lisi'] = 123465

print(phonebook1)


# 结果为：
# {'zhangsana': 1234, 'lisi': 123465, 'wangmazi': '789456'}
  • 修改键（注意：python中字典的键是不能直接修改，因为键是hash。）
  • 如果非要修改可以参考
dict={
    
    'a':1, 'b':2}
 
dict["c"] = dict.pop("a")
print(dict)
# 结果为;
# {'b': 2, 'c': 1}

查

  • dict.get(key, default=None)
    返回指定键的值，如果值不在字典中返回default值
phonebook = {
    
    
    'zhangsana':1234,
    'lisi':147258,
    'wangmazi':'789456'
    }

phonebook_get1 = phonebook.get('lisi', 123)
phonebook_get2 = phonebook.get('wangjie',None)

print(phonebook_get1)
print(phonebook_get2)
# 结果为：
# 147258
# None

内置方法

  • dict(items)
    -以列表返回可遍历的(键, 值) 元组数组
phonebook = {
    
    
    'zhangsana':1234,
    'lisi':147258,
    'wangmazi':'789456'
    }

phonebook_get1 = phonebook.items()


print(phonebook_get1)



# 结果为：
# dict_items([('zhangsana', 1234), ('lisi', 147258), ('wangmazi', '789456')])
  • dict.keys()
  • 以列表返回一个字典所有的键
phonebook = {
    
    
    'zhangsana':1234,
    'lisi':147258,
    'wangmazi':'789456'
    }

phonebook_get1 = phonebook.keys()


print(phonebook_get1)



# 结果为：
#dict_keys(['zhangsana', 'lisi', 'wangmazi'])
  • dict.values()
    以列表返回字典中的所有值
phonebook1 = {
    
    
    'zhangsana':1234,
    'lisi':147258,
    'wangmazi':'789456'
    }

phonebook1_values = phonebook1.values()

print(phonebook1_values)

集合

  • 集合是一个无序的，不重复的数据集合，特点是去重和无序。
  • 创建一个集合
jihe = {
    
    1,'5',(99)}
print(jihe)
print(type(jihe))
# {1, 99, '5'}
# <class 'set'>
  • 一个空集合必须用set（）
jihe = {
    
    }
print(jihe)
print(type(jihe))

jihe2 = set()
print(jihe2)
print(type(jihe2))
# 结果为：
# {}
# <class 'dict'>
# set()
# <class 'set'>
  • 去重
list_1 = [1,3,5,7,9,1,2,3,4,5]
test_1 = set(list_1)
print(test_1)

# 结果为：
# {1, 2, 3, 4, 5, 7, 9}

集合的增删

# 增加.add
test_1 = set('abc')
test_1.add('d')
print(test_1)
print(type(test_1))
# 结果为：
# {'b', 'c', 'd', 'a'}
# <class 'set'>


# 删除：.pop, remove(), clear(), discard()
# .pop
# 随机删除某一集合元素,并返回被删的元素值
test_1 = set('abc')
pop_va = test_1.pop()
print(pop_va)
print(test_1)
print(type(test_1))
# 结果为：
# b
# {'c', 'a'}
# <class 'set'>

# .remove()
#删除指定的元素(元素不存在会报错)：
test_1 = set('abc')
test_1.remove('b')
print(test_1)
print(type(test_1))
# 结果为：
# {'c', 'a'}
# <class 'set'>

# .discard()
# 删除指定元素(元素不存在不报错)：
test_1 = set('abc')
test_1.discard('b')
print(test_1)
print(type(test_1))
# 结果为：
# {'c', 'a'}
# <class 'set'>

集合的交并差

  • 交
test_1 = set('abcde')
test_2 = set('ABcde')
print(test_1.intersection(test_2))
print(test_1&test_2)
# 结果为：
# {'e', 'c', 'd'}
# {'e', 'c', 'd'}
  • 并
test_1 = set('abcde')
test_2 = set('ABcde')
print(test_1.union(test_2))
print(test_1|test_2)
# 结果为：
# {'a', 'B', 'b', 'd', 'e', 'c', 'A'}
# {'a', 'B', 'b', 'd', 'e', 'c', 'A'}
  • 差
test_1 = set('abcde')
test_2 = set('ABcde')
print(test_1.difference(test_2))
print(test_1-test_2)
print(test_2-test_1)
# 结果为：
# {'b', 'a'}
# {'b', 'a'}
# {'A', 'B'}

猜你喜欢

转载自blog.csdn.net/qq_38874239/article/details/108602515
今日推荐
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
GCC 14.1 发布
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
Java自定义时间格式
同步整形电路
在开发中最最最常用的字符串的属性大集合
Linux 查看端口占用并杀掉
Java基础四：ArrayList
多线程之死锁就是这么简单
mysql 基础命令集
awk 命令详解
Centos6.3编译安装nginx+php步骤
OCR （Optical Character Recognition，光学字符识别）
每日归档
更多
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022