python3学习笔记（一）——数字、字符串、列表、字典、元组

什么是python解释器？

　　python代码在解释器中运行。解释器是代码与计算机硬件之间的软件逻辑层。

python的执行过程                                                                                                                                    

源代码(.py文件) --> 编译 --> 字节码(.pyc文件) --> python虚拟机解释字节码-->执行

python的主要实现方式：CPython、JPython(Java)、IronPython(Windows)

表达式建立并处理对象-->表达式构成语句-->语句组成模块-->模块组成程序

Python核心数据类型：                                                                                                                           
数字
字符串
列表
字典
元组
集合
文件
None、布尔型
函数、模块、类

一、数字                                                                                            

1.加减乘除

>>> 3+5
8
>>> 3-5
-2
>>> 3*5
15
>>> 5/3
1.6666666666666667
>>> 5.0/3
1.6666666666666667
>>> 5//3
1
>>> 5.0//3
1.0
>>> -5//3
-2
>>> -7//3 # 向下取舍
-3
>>> 23 % 10
3
>>> 3**2
9

2.内置函数

>>> int(3.14)
3
>>> float(3)
3.0

3.内置数学模块

>>> import math
>>> math.pi
3.141592653589793
>>>import random

二、字符串 

字符串的特点：
　　1.字符串是单个字符的字符串序列，是有序的
　　2.不可变性，不可以对原始的字符串进行改变。
字符串操作：
>>> s = ‘hello world‘
1.计算字符串的长度

>>> len(s)
11

2.索引

>>> s[0]
‘h‘
>>> s[6]
‘w‘
>>> s[-1]
‘d‘
>>> s[-2]
‘l‘

3.切片

>>> s[:]
‘hello world‘
>>> s[0:4]    # [a,b)
‘hell‘
>>> s[2:4]
‘ll‘
>>> s[-5:-1]
‘worl‘
>>> s[-5:]
‘world‘

4.字符串拼接

>>> s1 = ‘hello ‘
>>> s2 = ‘world‘
>>> s1 + s2
‘hello world‘

5.字符串的方法
5.1.字符串大小写转换

>>> # 字符串首字符大写
... print("hello world".capitalize())
Hello worldprint("hello WORLD".swapcase())
>>> # 将字符串变为标题
... print("hello WORLD".title())
Hello World
>>> # 将字符串转为大写
... print("hello world".upper())
HELLO WORLD
>>> # 把字符串转为小写
... print("HELLO WORLD".lower())
hello world
>>> # 翻转字符串中的大小写
... print("hello WORLD".swapcase())
HELLO world

5.2.字符串分割

>>> # 以某个元素为分割点，将字符串分为3部分,从左往右找到的第一个元素为分割点
... print(‘helloworld‘.partition(‘o‘))
(‘hell‘, ‘o‘, ‘world‘)
>>> # 以某个元素为分割点，将字符串分为3部分，从右往左找到的第一个元素为分割点
... print(‘helloworld‘.rpartition(‘o‘))
(‘hellow‘, ‘o‘, ‘rld‘)
>>> # 替换原字符串中的元素,默认全部替换，可以指定替换几个（从左往右数）
... print("hello world".replace(‘o‘, ‘a‘, 1))
hella world
>>> # 以某个元素为分割点，将字符串分割,从左往右分割n次
... print("hello world".split(‘o‘, 1))
[‘hell‘, ‘ world‘]
>>> # 以某个元素为分割点，将字符串分割,从右往左分割n次
... print("hello world".rsplit(‘o‘, 1))
[‘hello w‘, ‘rld‘]
>>> # 按照行(‘\r‘, ‘\r\n‘, \n‘)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
... print(‘hello\nworld‘.splitlines(True))
[‘hello\n‘, ‘world‘]

5.3.字符串中查找元素

>>> # 统计某个字符串从索引n到y出现的次数，缺省为在整个字符串中查找
... print("hello world".count(‘o‘, 7, 10))
1
>>> # 在索引[n , y)之间查找元素，缺省为[:]返回元素的索引，如果没找到返回-1
... print("hello world".find(‘e‘))
1
>>> print("hello world".find(‘o‘, 0, 2))
-1
>>> # 在[n, y)之间找元素的索引值，没找到会报错
... print("hello world".index(‘o‘))
4
>>> print("hello world".index(‘e‘, 0, 5))
1

5.4.字符串判断

>>> # 判断字符串是否以某个元素开始
... print(‘helloworld‘.startswith(‘h‘))
True
>>> # 判断字符串的的从[n，y)的索引之间是否以某个字符结尾,返回值为布尔值
... print("hello world".endswith(‘e‘, 0, 2))
True
>>> # 判断是否是只有数字或字母
... print(‘abc123‘.isalnum())
True
>>> # 判断是否只含有字母
... print(‘abc‘.isalpha())
True
>>> # 判断字母是否都是小写
... print("Hello".islower())
False
>>> # 判断字符是不是空格
... print(" ".isspace())
True
>>> # 判断是不是字符串是不是标题(单词首字母是不是大写)
... print("Hello World".istitle())
True

5.5字符串格式化

>>> # 字符串居中，规定字符串的总长度，不够用其他字符补齐，默认是空格
... print("hello world".center(20, "#"))
####hello world#####
>>> # 把字符串中的\t替换为n个空格
... print("hello\tworld".expandtabs(tabsize=20))
hello               world
>>> print(‘#‘.join("hello world"))
h#e#l#l#o# #w#o#r#l#d
>>> # 规定输出字符的长度，并且左对齐,不足部分用指定字符补齐
... print("hello world".ljust(20, "#"))
hello world#########
>>> # 规定输出字符的长度，并且右对齐,不足部分用指定字符补齐
... print("hello world".rjust(20, "#"))
#########hello world
>>> # 去除字符串左边的的空格
... print(‘ hello‘.lstrip())
hello
>>> # 去除字符串右边的的空格
... print(‘hello ‘.rstrip())
hello
>>> # 去除字符串两边的的空格
... print(‘ hello ‘.strip())
hello
>>> # 指定字符串的长度，不够在前面补0
... print("123".zfill(5))
00123
>>> # 字符串的拼接
... print(‘hello ‘ + ‘world‘)
hello world
>>> print(‘hello ‘ * 3)
hello hello hello

6字符串的赋值

>>> s = ‘hello world‘
>>> print(s)
hello world
>>> s = "hello world"
>>> print(s)
hello world
>>> s = """hello
... world
... !!!"""
>>> print(s)
hello
world
!!!
>>> s = ‘hello\tworld‘
>>> print(s)
hello   world
>>> s = r‘hello\tworld‘
>>> print(s)
hello\tworld

三、列 表                                                                                              
列表的特点：
　　1.任意类型的对象的位置相关的有序集合
　　2.大小可变，可以修改
　　3.支持任意嵌套
1.计算列表长度

>>> l = [‘Tom‘,‘Bob‘,123,[‘boy‘,‘girl‘]]
>>> len(l)
4

2.索引

>>> l[-1]
[‘boy‘, ‘girl‘]
>>> l[2]
123
>>> l[3][1]
‘girl‘

3.切片

>>> l[:]
[‘Tom‘, ‘Bob‘, 123, [‘boy‘, ‘girl‘]]
>>> l[1:3]
[‘Bob‘, 123]
>>> l[-2:-1]
[123]
>>> l[-2:]
[123, [‘boy‘, ‘girl‘]]

4.列表的方法

4.1添加

#在尾部插入一项
>>> l = [‘刘备‘,‘关羽‘,‘张飞‘]
>>> l.append(‘诸葛亮‘)
>>> l
[‘刘备‘, ‘关羽‘, ‘张飞‘, ‘诸葛亮‘]
#把一个列表添加到另一个列表末尾
>>> L1 = [‘刘备‘,‘关羽‘,‘张飞‘]
>>> L2 = [‘姜维‘,‘诸葛亮‘]
>>> L1.extend(L2)
>>> L1
[‘刘备‘, ‘关羽‘, ‘张飞‘, ‘姜维‘, ‘诸葛亮‘]
#在指定索引位置插入元素
>>> l
[‘刘备‘, ‘关羽‘, ‘张飞‘]
>>> l.insert(1,‘马超‘)
>>> l
[‘刘备‘, ‘马超‘, ‘关羽‘, ‘张飞‘]

4.2删除

#删除所有元素
>>> l.clear()
>>> l
[]
#根据索引删除元素并打印删除的元素
>>> l
[‘刘备‘, ‘马超‘, ‘关羽‘, ‘张飞‘]
>>> l.pop()    #无参数删除最后一个
‘张飞‘
>>> l
[‘刘备‘, ‘马超‘, ‘关羽‘]
>>> l.pop(1)
‘马超‘
>>> l
[‘刘备‘, ‘关羽‘]
#删除指定元素
>>> l = [‘刘备‘,‘关羽‘,‘张飞‘]
>>> l.remove("关羽")
>>> l
[‘刘备‘, ‘张飞‘]

4.3拷贝

>>> l1 = l.copy()
>>> l1
[‘刘备‘, ‘关羽‘, ‘张飞‘]
4.4查找
#统计某个元素出现的次数
>>> l.count(‘关羽‘)
1
#查找[a,b)之间某元素的索引值
>>> L1
[‘刘备‘, ‘关羽‘, ‘张飞‘, ‘姜维‘, ‘诸葛亮‘]
>>> L1.index(‘关羽‘)
1
>>> L1.index(‘关羽‘,2,4)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: ‘关羽‘ is not in list

4.5排序

# 倒序
>>> l = [‘b‘,‘B‘,‘a‘,‘h‘]
>>> l.reverse()
>>> l
[‘h‘, ‘a‘, ‘B‘, ‘b‘]
# 升序
>>> l.sort()
>>> l
[‘B‘, ‘a‘, ‘b‘, ‘h‘]
降序
>>> l.sort(reverse = True)
>>> l
[‘h‘, ‘b‘, ‘a‘, ‘B‘]

5.列表解析

>>> row = [[1,2,3],[4,5,6],[7,8,9]]
>>> row
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> col = [i[1] for i in row ]
>>> col
[2, 5, 8]
>>> [i[1]+1 for i in row]
[3, 6, 9]
>>> [i[1] for i in row if i[1] % 2 == 0]
[2, 8]

四、字典                                                                                               

字典的特点：
　　1.通过键来存储
　　2.没有固定的从左到右的顺序
　　3.可以改变
1.字典的创建

>>> d = {‘name‘:‘Tom‘,‘job‘:‘IT‘}
>>> d
{‘job‘: ‘IT‘, ‘name‘: ‘Tom‘}
>>> d[‘age‘] = 18
>>> d[‘sex‘] = ‘boy‘
>>> d
{‘job‘: ‘IT‘, ‘sex‘: ‘boy‘, ‘name‘: ‘Tom‘, ‘age‘: 18}

2.索引

>>> d = {‘name‘:‘Tom‘,‘job‘:‘IT‘}
>>> d
{‘name‘: ‘Tom‘, ‘job‘: ‘IT‘}
>>> d[‘name‘]
‘Tom‘

3.键的排序

>>> d.keys()
dict_keys([‘name‘, ‘job‘])
>>> list(d.keys())
[‘name‘, ‘job‘]
>>> Ks = list(d.keys())
>>> Ks.sort()
>>> for k in Ks:
... print(k,‘-->‘,d[k])
...
job --> IT
name --> Tom

4.判断

>>> d
{‘name‘: ‘Tom‘, ‘job‘: ‘IT‘}
# 判断一个键是否存在
>>> ‘name‘ in d
True

5.字典的方法

5.1删除

# 清空字典
>>> d = {‘name‘: ‘Tom‘, ‘job‘: ‘IT‘}
>>> d.clear()
>>> d
{}

#删除指定键
>>> d.pop(‘sex‘,‘not find‘)
‘not find‘
>>> d.pop(‘name‘)
‘Tom‘
#随机删除键值对，字典为空时报错
>>> d.popitem()
(‘job‘, ‘IT‘)
>>> d.popitem()
(‘name‘, ‘Tom‘)
>>>
>>> d.popitem()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: ‘popitem(): dictionary is empty‘

5.2拷贝

>>> d = {‘name‘: ‘Tom‘, ‘job‘: ‘IT‘}
>>> D = d.copy()
>>> D
{‘name‘: ‘Tom‘, ‘job‘: ‘IT‘}

5.3创建字典

>>> l
[‘name‘, ‘age‘]
>>>
>>> d={}
>>> d.fromkeys(l,‘abc‘)
{‘age‘: ‘abc‘, ‘name‘: ‘abc‘}
# 如果键不存在添加一个，如果存在不做更改
>>> d.setdefault(‘sex‘,‘boy‘)
‘boy‘
>>> d
{‘job‘: ‘IT‘, ‘sex‘: ‘boy‘, ‘name‘: ‘Tom‘}
>>> d.setdefault(‘sex‘,‘girl‘)
‘boy‘
>>> d
{‘job‘: ‘IT‘, ‘sex‘: ‘boy‘, ‘name‘: ‘Tom‘}
#合并字典，把一个字典加到另一个字典
>>> d1 = {‘name‘: ‘Tom‘, ‘job‘: ‘IT‘}
>>> d2 = {‘sex‘:‘boy‘}
>>> d1.update(d2)
>>> d1
{‘job‘: ‘IT‘, ‘sex‘: ‘boy‘, ‘name‘: ‘Tom‘}

5.4查找

# 根据键查找值
>>> d = {‘name‘: ‘Tom‘, ‘job‘: ‘IT‘}
>>> d.get(‘name‘)
‘Tom‘
>>> d.get(‘sex‘,‘not find‘)
‘not find‘
5.5
>>> d.items()
dict_items([(‘job‘, ‘IT‘), (‘name‘, ‘Tom‘)])
>>> for k,v in d.items():
... print(k,v)
...
job IT
name Tom
>>> for k in d.items():
... print(k)
...
(‘job‘, ‘IT‘)
(‘name‘, ‘Tom‘)

五、元组                                                                                            

元组的特点：
　　1.不可变性
　　2.支持嵌套
>>> t = (1,2)
1.计算元组的长度

>>> len(t)
2

2.元组的方法：

>>> t.count(1)
1
>>> t.index(1)
0

原文地址：https://www.cnblogs.com/rockley/p/8366998.html

时间： 2024-09-30 06:25:57

python3学习笔记（一）——数字、字符串、列表、字典、元组的相关文章

Python 学习笔记【09】列表、元组

定义列表 1 names = ["Zhangyang", "Guyun", "Xiangpeng", "Xuliangchen"] 通过下标取列表中的值 1 print(names[0], names[2]) 切片:取多个元素   1 print(names[1:3]) # 取第二个到第三个值 注:顾头不顾尾 2 3 print(names[0:3]) # 取第一个到第三个值 4 5 print(names[-1]) # 取最

python学习笔记（五）之字典2

python学习笔记(五)之字典2编程实战中经常用到实例1:copy >> ad = {"name":"wtf","hig":"180"}>> bd = ad>> bd{'name': 'wtf', 'hig': '180'}>> id (ad)4539954352>> id (bd)4539954352说明:一个对象贴上两个标签,使用赋值,实现了所谓的"假

python学习笔记2：字符串

python学习笔记2:字符串 总结:字符串是不可变变量,不能通过下标修改其值 字符串的方法都不会改变字符串原来的值,而是新生成一个字符串 一.3种写法--单引号,双引号,三引号 二.下标和切片 下标:字符串里每个字符所在的位置,也叫索引.strname[n] ,表示strname这个字符串的下标为n对应的字符的值. 切片:取字符串一个下标区间的值. strname[n:m],表示strname这个字符串,下标n到m这个区间内的值,注意n:m取值,顾前不顾后. 三.字符串遍历 in 和not i

python基础教程_学习笔记5：字符串

字符串 基本字符串操作 字符串也是序列,因此序列的基本操作(索引.分片.连接.乘法.长度.求最大值和最小值.成员资格)对字符串同样适用: 索引 >>> 'a_string'[0] 'a' 长度 >>> len('a_string') 8 求最大值 >>> max('a_string') 't' 求最小值 >>> min('a_string') '_' 乘法 >>> 'a_string'*2 'a_stringa_st

MySQL学习笔记之九 字符串模式匹配

我们在使用查询的时候,经常会碰到模糊条件查询,而模糊查询就涉及到了字符串模式匹配. 在这里,主要讲两个:标准的SQL模式匹配.扩展正则表达式模式匹配.     一.标准的SQL模式匹配 SQL的模式匹配允许你使用"_"匹配任何单个字符,而"%"匹配任意数目字符(包括零个字符).在MySQL中,SQL的模式缺省是忽略大小写的.下面显示一些例子.注意在你 使用SQL模式时,你不能使用=或!=:而使用LIKE或NOT LIKE比较操作符. 为了找出包含正好5个字符的名字,

Python学习笔记__3.3章 列表生成式

# 这是学习廖雪峰老师python教程的学习笔记 1.概览 列表生成式即List Comprehensions,是Python内置的非常简单却强大的可以用来创建list的生成式 1.生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] list(range(1, 11)) 2.列表生成式 [1x1, 2x2, 3x3, ..., 10x10] [x*x for x in range(1,11)] 3.使用两层循环 >>>[m + n for m in 'ABC'

Swift学习笔记四：数组和字典

最近一个月都在专心做unity3d的斗地主游戏,从早到晚,最后总算是搞出来了,其中的心酸只有自己知道.最近才有功夫闲下来,还是学习学习之前的老本行--asp.net,现在用.net做项目流行MVC,而不是之前的三层,既然技术在更新,只能不断学习,以适应新的技术潮流! 创建MVC工程 1.打开Visual studio2012,新建MVC4工程 2.选择工程属性,创建MVC工程 3.生成工程的目录 App_Start:启动文件的配置信息,包括很重要的RouteConfig路由注册信息 Conten

ADO.NET学习笔记之连接字符串

ADO.NET 2.0学习笔记之连接字符串 刚刚入门不久,想什么学习下dot net平台,就先从数据访问入手吧,从今天开始认真学习ado.net 2.0,为将来发展做好坚实基础. 连接字符串 SQL Client .net数据提供程序在连接到数据库时极其灵活,它提供了多种用以生成连接字符串的方式.可以使用关键字,例如“Data Sourse”.“Initial Catalog”,也可以使用"Server".“Database”等旧术语. 下面是两个例子,用于连接到SqlServer数据

JavaScript学习笔记第一天——字符串连接的N种方法

Javascript 字符串的连接方法有多种,但效率却有很大区别. 1.逐个字符串相加 var arr = ['item 1', 'item 2', 'item 3', ...]; var list = ''; for (var i = 0, l = arr.length; i < l; i++) { list += '<li>' + arr[i] + '</li>'; } list = '<ul>' + list + '</ul>'; 这种最常见的,