Python---基础----数据类型的内置函数(主要介绍字符串、列表、元组、字典、集合的内置函数)(二)
2019-05-24
--------------------------------
一、
# splitlines() 以换行切割字符串
s = '''日照香炉生紫烟\n疑是银河落九天\n飞流直下三千尺'''
print(s.splitlines())
二、
# join() 将列表按照指定字符串连接
list1 = ['日照香炉生紫烟','疑是银河落九天','飞流直下三千尺']
s = '*'.join(list1)
print(s)
三、
# ljust() 指定字符串的长度,内容靠左边
s = 'abc'
print(len(s))
print(s.ljust(5, '#'))
四、
s = 'abc'
print(len(s))
print(s.ljust(5)+'aa')
print(s.center(5, '#'))
print(s.rjust(5, '#'))
# lstrip() 去掉左侧指定字符,默认空格
# rstrip() 去掉右侧指定字符,默认空格
print('- - -'+s.strip()+'- - -')
print('- - -'+s+'- - -')
print(s.lstrip('a'))
print(s.lstrip('b'))
print(s.rstrip('c'))
s = 'abc'
print(s.zfill(5))
# translate() 进行字符串替换
s = '今天晚上我吃的是小炒肉,可好吃了'
table = s.maketrans('小炒肉', '大白菜')
print(table)
print(s.translate(table))
class list(object)
| list(iterable=(), /)
|
| Built-in mutable sequence.
|
| If no argument is given, the constructor creates a new empty list.
| The argument must be an iterable if specified.
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Implement self+=value.
|
| __imul__(self, value, /)
| Implement self*=value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the list.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(self, /)
| Return the size of the list in memory, in bytes.
|
| append(self, object, /)
| Append object to the end of the list.
|
| clear(self, /)
| Remove all items from list.
|
| copy(self, /)
| Return a shallow copy of the list.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| extend(self, iterable, /)
| Extend list by appending elements from the iterable.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| insert(self, index, object, /)
| Insert object before index.
|
| pop(self, index=-1, /)
| Remove and return item at index (default last).
|
| Raises IndexError if list is empty or index is out of range.
|
| remove(self, value, /)
| Remove first occurrence of value.
|
| Raises ValueError if the value is not present.
|
| reverse(self, /)
| Reverse *IN PLACE*.
|
| sort(self, /, *, key=None, reverse=False)
| Stable sort *IN PLACE*.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
list1 = [1,2,3,4,5]
print(list1.append(5))
list1 = [1,1,2,5,1,3]
print(list1.count(5))
list1 = [1,2,3,4,5]
list2 = [6,7,8,9,10]
list3 = list1.extend(list2)
print(list1)
print(list2)
print(list3)
print(list1 + list2)
list1 = [1,2,3,4,5,3]
print(list1.index(3))
#print(list1.index)
print(list1.index(3, 2, 5))
list1 = [1,2,3,4,5]
list1.insert(2,9)
print(list1)
list1 = [1,2,3,4,5]
list1.pop()
print(list1)
list1 = ['a', 'b', 'c', 'd', 'e']
list1.remove('b')
print(list1)
list1 = [5,2,4,6,1,9]
list1.sort()
print(list1)
list1 = [1,2,3,4]
list1.reverse()
print(list1)
list1 = [5,2,4,6,1,9]
list1.sort()
print(list1)
list1.sort(reverse=True)
tuple1 = (3, 2, 4, 1, 3, 6)
print(tuple1.count(3))
tuple1 = (3, 2, 4, 1, 3, 6)
print(tuple1.index(3))
tuple1 = (3, 2, 4, 1, 3, 6)
print(tuple1.index(3))
print(tuple1.index(3,1,5))
dict1 = {'a':1, 'b':2, 'c':3}
dict2 = dict1.copy()
print(dict2)
list1 = ['a', 'b', 'c']
dict1 = {}.fromkeys(list1)
dict2 = {}.fromkeys(list1, 3)
print(dict1,dict2)
dict1 = {'a':1, 'b':2, 'c':3}
print(dict1.get('b'))
dict1 = {'a':1, 'b':2, 'c':3}
print(dict1.get('b'))
print(dict1.get('d'))
print(dict1.get('d', 4))
dict1 = {'a':1, 'b':2, 'c':3}
for k,v in dict1.items():
print(k,v)
dict1 = {'d':4, 'a':1, 'b':2, 'c':3}
print(dict1.popitem())
dict1 = {'d':4, 'a':1, 'b':2, 'c':3}
print(dict1.setdefault('e',5))
print(dict1)
dict1 = {'d':4, 'a':1, 'b':2, 'c':3}
dict1.update({'a':3})
print(dict1)
class set(object)
| set() -> new empty set object
| set(iterable) -> new set object
|
| Build an unordered collection of unique elements.
|
| Methods defined here:
|
| __and__(self, value, /)
| Return self&value.
|
| __contains__(...)
| x.__contains__(y) <==> y in x.
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __gt__(self, value, /)
| Return self>value.
|
| __iand__(self, value, /)
| Return self&=value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __isub__(self, value, /)
| Return self-=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __ixor__(self, value, /)
| Return self^=value.
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __rand__(self, value, /)
| Return value&self.
|
| __reduce__(...)
| Return state information for pickling.
|
| __repr__(self, /)
| Return repr(self).
|
| __ror__(self, value, /)
| Return value|self.
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rxor__(self, value, /)
| Return value^self.
|
| __sizeof__(...)
| S.__sizeof__() -> size of S in memory, in bytes
|
| __sub__(self, value, /)
| Return self-value.
|
| __xor__(self, value, /)
| Return self^value.
|
| add(...)
| Add an element to a set.
|
| This has no effect if the element is already present.
|
| clear(...)
| Remove all elements from this set.
|
| copy(...)
| Return a shallow copy of a set.
|
| difference(...)
| Return the difference of two or more sets as a new set.
|
| (i.e. all elements that are in this set but not the others.)
|
| difference_update(...)
| Remove all elements of another set from this set.
|
| discard(...)
| Remove an element from a set if it is a member.
|
| If the element is not a member, do nothing.
|
| intersection(...)
| Return the intersection of two sets as a new set.
|
| (i.e. all elements that are in both sets.)
|
| intersection_update(...)
| Update a set with the intersection of itself and another.
|
| isdisjoint(...)
| Return True if two sets have a null intersection.
|
| issubset(...)
| Report whether another set contains this set.
|
| issuperset(...)
| Report whether this set contains another set.
|
| pop(...)
| Remove and return an arbitrary set element.
| Raises KeyError if the set is empty.
|
| remove(...)
| Remove an element from a set; it must be a member.
|
| If the element is not a member, raise a KeyError.
|
| symmetric_difference(...)
| Return the symmetric difference of two sets as a new set.
|
| (i.e. all elements that are in exactly one of the sets.)
|
| symmetric_difference_update(...)
| Update a set with the symmetric difference of itself and another.
|
| union(...)
| Return the union of sets as a new set.
|
| (i.e. all elements that are in either set.)
|
| update(...)
| Update a set with the union of itself and others.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
print(a)
list1 = [1,2,3,4]
a = set(list1)
print(a)
set1 = {5, 1, 2, 3, 4}
set1.add(6)
print(set1)
a = {'a', 'b', 'f', 4}
a.pop()
print(a)
a = {'a', 'b', 'f', 4}
a.remove(4)
print(a)
a = {'a', 'b', 'f', 4}
a.discard(4)
print(a)
a = {'a', 'b', 'f', 4}
a.discard(4)
print(a)
a.discard(4)
print(a)
# difference_update() 区别就是第一个返回一个新的集合,第二个是把原来集合覆盖
set1 = {1,2,3,4,7}
set2 = {2,4,8,111,24}
set3 = set1.difference(set2)
print(set3)
set4 = set1.difference_update(set2)
print(set4)
Python---基础----数据类型的内置函数(主要介绍字符串、列表、元组、字典、集合的内置函数)(二)的更多相关文章
- Python数据类型-布尔/数字/字符串/列表/元组/字典/集合
代码 bol = True # 布尔 num = 100000000; # 数字 str = "fangbei"; # 字符串 str_cn = u"你好,方倍" ...
- Python第三天 序列 5种数据类型 数值 字符串 列表 元组 字典 各种数据类型的的xx重写xx表达式
Python第三天 序列 5种数据类型 数值 字符串 列表 元组 字典 各种数据类型的的xx重写xx表达式 目录 Pycharm使用技巧(转载) Python第一天 安装 shell ...
- Python第三天 序列 数据类型 数值 字符串 列表 元组 字典
Python第三天 序列 数据类型 数值 字符串 列表 元组 字典 数据类型数值字符串列表元组字典 序列序列:字符串.列表.元组序列的两个主要特点是索引操作符和切片操作符- 索引操作符让我 ...
- 《python基础教程(第二版)》学习笔记 列表/元组(第2章)
<python基础教程(第二版)>学习笔记 列表/元组(第2章)序列中的下标从0开始x='ABC' ==> x[0]='A', x[1]='B', x[2]='C'负数索引从右边开始 ...
- **python中列表 元组 字典 集合
列表 元组 字典 集合的区别是python面试中最常见的一个问题.这个问题虽然很基础,但确实能反映出面试者的基础水平. 1.列表 列表是以方括号“[]”包围的数据集合,不同成员以“,”分隔. 列表的特 ...
- python中列表 元组 字典 集合的区别
列表 元组 字典 集合的区别是python面试中最常见的一个问题.这个问题虽然很基础,但确实能反映出面试者的基础水平. (1)列表 什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单.比如,统计 ...
- python的学习笔记01_4基础数据类型列表 元组 字典 集合 其他其他(for,enumerate,range)
列表 定义:[]内以逗号分隔,按照索引,存放各种数据类型,每个位置代表一个元素 特性: 1.可存放多个值 2.可修改指定索引位置对应的值,可变 3.按照从左到右的顺序定义列表元素,下标从0开始顺序访问 ...
- Day 07 数据类型的内置方法[列表,元组,字典,集合]
数据类型的内置方法 一:列表类型[list] 1.用途:多个爱好,多个名字,多个装备等等 2.定义:[]内以逗号分隔多个元素,可以是任意类型的值 3.存在一个值/多个值:多个值 4.有序or无序:有序 ...
- python元组-字典-集合及其内置方法(下)
列表补充 补充方法 清空列表 clear # clear 清空列表 l = [1, 2, 3, 4, 4] print(l.clear()) # clear没有返回值(None) print(l) # ...
- Python入门基础学习(列表/元组/字典/集合)
Python基础学习笔记(二) 列表list---[ ](打了激素的数组,可以放入混合类型) list1 = [1,2,'请多指教',0.5] 公共的功能: len(list1) #/获取元素 lis ...
随机推荐
- Linux内核调试方法总结之反汇编
Linux反汇编调试方法 Linux内核模块或者应用程序经常因为各种各样的原因而崩溃,一般情况下都会打印函数调用栈信息,那么,这种情况下,我们怎么去定位问题呢?本文档介绍了一种反汇编的方法辅助定位此类 ...
- OGG-DDL复制
http://blog.sina.com.cn/s/blog_96d348df0102vg6q.html OGG目前只支持Oracle和TeraData的ddl复制,Oracle数据库能够支持除去数据 ...
- MDX 入门
之前用到的SQL,解释:结构化查询语言(Structured Query Language)(发音:/ˈes kjuː ˈel/ "S-Q-L"),是一种特殊目的的编程语言,是一种 ...
- 013-elasticsearch5.4.3【五】-搜索API【二】term术语查询-termQuery、rangeQuery、existsQuery、prefixQuery、wildcardQuery、regexpQuery、fuzzyQuery
一.概述 虽然全文查询将在执行之前分析查询字符串,但Term级查询将根据存储在倒排索引中的确切术语进行操作. 这些查询通常用于结构化数据,如keyword.数字,日期和枚举,而不是全文字段.或者,它们 ...
- 阶段1 语言基础+高级_1-3-Java语言高级_1-常用API_1_第7节 Arrays工具类_16_数组工具类Array
在java.util的包下面.在这个包的下面是需要导包的,只有lang 的包下面是不需要导包的 查看jdk1.6的手册 Arrays让我们想起了数组,说明它提供了与数组相关的方法 我们可以看到 toS ...
- 深入理解任何Binder Client都可以直接通过ServiceManager的0这个Binder句柄创建一个BpBinde
ServiceManager是安卓中一个重要的类,用于管理所有的系统服务,维护着系统服务和客户端的binder通信.对此陌生的可以先看系统服务与ServiceManager来了解应用层是如何使用Ser ...
- layui中获取全部提交的数据
<form class="layui-form" action="">...........input textarea ......</fo ...
- 第四周实验报告&实验总结
试验报告2 写一个名为Rectangle的类表示矩形.其属性包括宽width.高height和颜色color,width和height都是double型的,而color则是String类型的.要求该类 ...
- Developer Express 第三方控件使用系列方法
本人目前从事的开发工作主要是以C#语言进行的相关C/S的开发,在工作中也要求使用Developer Express第三方控件所以这一系列的控件使用说明都将以C#语言进行代码说明.平时工作中会慢慢的收集 ...
- 极*Java速成教程 - (3)
Java语言基础 访问权限控制 Java是一个面向对象的语言,当你不是它所设计的要面向的对象时,它就不会给你看你不该看到的东西,也就是"访问权限控制". 亲疏有别,才能权限控制 包 ...