澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

Python中元组列表与字典学习笔记,零基础Python知

2019-07-06 作者:www.8455.com   |   浏览(124)

 开始了,继续说!字符串替换,就是预留着空间,后边再定义要填上什么,这种叫字符串格式化,其有两种方法: %    和 format

引言

 

字符串属于标量存储、不可改变、顺序访问的数据类型。字符串属于序列的一种,因此对字符串可行的序列操作对类似元组和列表同样适用。

PyCharm 一些简单常用设置操作
设置模板
File->Settings->Editor->File and Code Templates

%s  就是一个占位符,这个占位符可以被其它的字符串代替

这篇文章介绍python中的三种组合数据类型,文章后半段会介绍如何在这些组合数据类型中使用"分片"取出数据。

标准数据类型:

1. 字符串的创建

类似于数字类型的创建,直接将字符串赋值给变量即可创建一个新的字符串对象。

>>> a = 'string'                # 使用单引号
>>> a = "string"                # 使用双引号,在 Python 中,单引号和双引号没有区别
>>> a = '''
... a
... string 
... block '''                   # 使用三引号,字符串块(三引号在某些情况下可以起到注释掉不需要执行的代码的作用)
>>> a
'nanstringnblock '
>>> a = ''
''                              # 空字符

对变量重新赋值一个新的字符串即可 “ 更新 ” 变量

>>> a = 'string1'
>>> a
'string1'
>>> a = 'string2'
>>> a
'string2'

//切换python版本
File->settings->Project interpreter ->选择版本

>>> "I like %s" % "python"

文章目录

共6种:Number(数字),String(字符串),List(列表),Tuple(元组),Sets(集合),Dictionary(字典)

2. 转义字符

一个反斜线加一个单一字符,可以表示一些通常情况下不可打印的字符,这种组合称为转义字符。

>>> a = 'string1nstring2'                # n 代表换行符,虽然由两个字符组成,但在最终表示中会被一个单一字符替代
>>> print a
string1
string2

常用的转义字符包括:

转义字符 代表含义
n 换行
t 横向制表符(tab)
\ 反斜线( )
' 单引号
" 双引号
u 后跟四位十六进制数,表示 Unicode 字符串

当我们不需要对字符进行转义时,可以使用原始字符串操作符 raw 字符串。在原始字符串中,所有的字符都是直接按照输入的字符来使用,没有转义或不能打印的字符。使用 raw 只需要在字符串前加 r/R 即可。

>>> a = r'string1nstring2'
>>> print a
string1nstring2                # 输出的结果和输入一样,没有进行转义
>>> a
'string1\nstring2'             # Python 自身在显示 '' 时也会使用转义字符 '\'
  • 注:在交互模式下 print a 和直接显示 a 的区别:使用 print 可以显示变量格式化以后的显示效果,而直接输入变量名则会显示变量的值在 Python 内部的表示形式。

#!use/bin/env python
# -*- coding:utf-8 -*-  #设置utf-8编码
var=1
ca=2
ca =var
print(ca)
#python 运算符基本一样

'I like python'

0×1.元组

 

3. Unicode 字符串

如果需要使用 Unicode 字符串时,可以在字符串前加 u/U 即可使用 Unicode 字符串

>>> a = u'abc'
>>> a
u'abc'
>>> a = u'u1234'                 # 使用 u 转义字符,u 后为十六进制
>>> print a
ሴ

#有两个不同运算符号,**代表求幂 // 代表除取整
# a**b a的b次方
#9/2= 4.5 #python3 可以自动转成float类型
# 9//2 =4

占位符 说明
%s 字符串(采用str()的显示)
%r 字符串(采用repr()的显示)
%c 单个字符
%b 二进制整数
%d 十进制整数
%i 十进制整数
%o 八进制整数
%x 十六进制整数
%e 指数 (基底写为e)
%E 指数 (基底写为E)
%f 浮点数
%F 浮点数,与上相同
%g 指数(e)或浮点数 (根据显示长度)
%G 指数(E)或浮点数 (根据显示长度)

在python中,元组使用中括号来创建,如果括号中仅包含一个元素,需要在元素末尾添加一个逗号(不添加逗号数据会被创建成字符串或数值数据类型),元组在创建后,不能添加删除其中的元素,其值是固定不变的,请看下面的实例:

本次学习主要是和数据类型混个脸熟,知道每样东西干什么的,有什么特点。具体用法和数据类型的方法,查工具书就行。

4. 基本操作(适用于所有序列对象)

  • 比较操作

    字符串进行比较操作时按照在 ASCII 或 Unicode 中的数值大小进行比较

  • 连接操作

    可以使用 ' ' 操作符对字符串进行连接

a = 'a'
b = 'b'
a b
'ab'
```

  • 重复操作

    使用 '*' 操作符将字符串重复 N 次

a = 'a'
a * 7
'aaaaaaa'
```

  • 成员操作

    in / not in 可以用于判断一个字符或字符串是否出现在另一个字符串中

'ab' in 'abcd'
True
'ac' in 'abcd'
a = 'string1'
>>> a
'string1'
>>> a = 'string2'
>>> a
'string2'
### 2. 转义字符 一个反斜线加一个单一字符,可以表示一些通常情况下不可打印的字符,这种组合称为转义字符。
>>> a = 'string1nstring2' # n 代表换行符,虽然由两个字符组成,但在最终表示中会被一个单一字符替代
>>> print a
string1
string2
常用的转义字符包括: | 转义字符 | 代表含义 | | ------------ | ------------ | | n | 换行 | | t | 横向制表符(tab)| | \ | 反斜线( )| | ' | 单引号 | | " | 双引号 | | u | 后跟四位十六进制数,表示 Unicode 字符串 | 当我们不需要对字符进行转义时,可以使用原始字符串操作符 raw 字符串。在原始字符串中,所有的字符都是直接按照输入的字符来使用,没有转义或不能打印的字符。使用 raw 只需要在字符串前加 r/R 即可。
>>> a = r'string1nstring2'
>>> print a
string1nstring2 # 输出的结果和输入一样,没有进行转义
>>> a
'string1nstring2' # Python 自身在显示 '' 时也会使用转义字符 ''
- 注:在交互模式下 `print a` 和直接显示 `a` 的区别:使用 `print` 可以显示变量格式化以后的显示效果,而直接输入变量名则会显示变量的值在 Python 内部的表示形式。 ### 3. Unicode 字符串 如果需要使用 Unicode 字符串时,可以在字符串前加 u/U 即可使用 Unicode 字符串
>>> a = u'abc'
>>> a
u'abc'
>>> a = u'u1234' # 使用 u 转义字符,u 后为十六进制
>>> print a

### 4. 基本操作(适用于所有序列对象) - 比较操作 字符串进行比较操作时按照在 ASCII 或 Unicode 中的数值大小进行比较 - 连接操作 可以使用 ' ' 操作符对字符串进行连接
>>> a = 'a'
>>> b = 'b'
>>> a b
'ab'
- 重复操作 使用 '*' 操作符将字符串重复 N 次
>>> a = 'a'
>>> a * 7
'aaaaaaa'
- 成员操作 in / not in 可以用于判断一个字符或字符串是否出现在另一个字符串中
>>> 'ab' in 'abcd'
True
>>> 'ac' in 'abcd'
False
'ac' not in 'abcd'
True
```

字符串处理

string.format()的格式化方法,其中{索引值}作为占位符,这个好变着花样的玩哦,这个不错,嘻嘻

#创建三个元组,b元组仅包含一个字符串元素,所以末尾需要添加一个逗号,否则b将被创建为字符串对象,c元组是一个多维元组,包含了a和b元组
          >>> a=(1,2,3,4,5)
          >>> b=("www.qingsword.com",)
          >>> c=(a,b)

排好队,一个一个来。

5. 索引和切片(适用于所有的列表和对象)

序列对象从 0 开始进行索引,通过指定元素索引或切片对序列对象中的元素进行访问,语法如下:squence[index]

>>> a = 'string'
>>> a[0]
's'                                  # 序列的索引从 0 开始
>>> a[5]
'g'                                  # 序列索引的最大值比序列的长度小 1 

除此之外,还可以使用 负索引,范围是 -1 到序列的负长度。正负索引的区别在于正索引以序列的开始为起点( 0 ),负索引以序列的结束为起点( -1 )。负索引 序列长度 = 正索引

>>> a[-1]
'g'                                  # 负索引从 -1 开始
>>> a[-6]
'a'                                  # 负索引的最大值是序列的负长度,正索引的最大值是长度 len(squence) - 1

如果在访问序列的索引越界会引发一个异常:

>>> a[6]                                      # 正索引的最大值应该是长度 - 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

通过索引可以访问指定偏移量的某一个元素,而切片操作则可用来访问序列中指定的多个元素。切片操作只需要给出切片的开始和结束的索引值,中间用 ' : ' 分隔开即可: squence [ start_index : end_index ]

>>> a[1:3]
'tr'                            # 切片会截取从起始索引到结束索引,但不包括结束索引
>>> a[:3]
'str'                           # 如果不指定起始索引,默认为序列的开始
>>> a[1:]     
'tring'                         # 如果不指定结束索引,默认到序列的结束
>>> a[:]
'string'                        # 需要指出的是,所有字符串的操作都相当于创建了一个新的字符串,通过这种方法可以对字符串进行拷贝
>>> a[1:-1]
 'trin'                         # 在切片中同样可以使用负索引

切片操作还有第三个参数,起到类似步长的作用。不指定时默认为 1

>>> a[::2]
'srn'
>>> a[::-1]
'gnirts'                        # 可以通过这样来获得一个序列的倒序

切片不同于索引,不存在越界引起的异常

>>> a[-100:100]
'string'                        # 在切片中当起始或结束索引越界会使用默认值

在切片中使用 None

>>> a[:0]
''                              # 在结束索引使用 0 时会返回空字符串
>>> a[:None]
'string'                        # 使用 None 则会返回整个字符串
>>> a[None:]
'string'                        
>>> a[None:None]
'string'

a=1 #声明一个变量 值为1 动态变量 可以随时更改变量类型
b="abc你好" #定义一个字符串
c="bc"
print (b)
ret="bc" in c #代表 字符串"bc" 是否在c 变量中 在true 不在false
print (ret)

>>> s1 = "I like {0}".format("python")

          #分别打印出三个元组中的元素
          >>> print(a)
          (1, 2, 3, 4, 5)
          >>> print(b)
          ('www.qingsword.com',)
          >>> print(c)
          ((1, 2, 3, 4, 5), ('www.qingsword.com',))

 

6. 序列的一些内建函数

对序列对象有一些通用且常用的内建函数:

  • len():返回序列中元素的长度
>>> len(a)
6                               # 返回字符串的长度
  • max()min():返回序列中的最大值和最小值
>>> max(a)
't'                             # 返回字符串元素中的最大值
>>> min(a)
'g'                             # 返回字符串元素中的最小值
  • sorted():对序列中的对象进行排序
>>> sorted(a)
['g', 'i', 'n', 'r', 's', 't']
  • reversed():对列表中的所有元素反序输出
>>> for  i in reversed(a):
...    print i,
g n i r t s
  • enumerate():生成一个 enumerate 对象,该对象为每个元素的索引和值组成的元组
>>> for i in enumerate(a):
...     print i
...
(0, 's')
(1, 't')
(2, 'r')
(3, 'i')
(4, 'n')
(5, 'g')
  • zip():接受两个序列参数,生成一个列表,列表中的元素分别为由两个参数按顺序的两个元素所组成的元组
>>> zip(a, a)
[('s', 's'), ('t', 't'), ('r', 'r'), ('i', 'i'), ('n', 'n'), ('g', 'g')]

基本数据类型:
数字 int
字符串 str
布尔值 bool
列表 list
元组 tuple
字典 dict

>>> s1

          #打印出a元组第一个元素,python的索引起始是从0开始的
          >>> print(a[0])
          1

数字:

7. 字符串类型函数

  • raw_input():可以使用给定的字符串提示用户输入并将输入返回赋值给变量。
>>> a = raw_input("Please input something: ")    # 函数接受的字符串参数即为输出在屏幕上提示用户输入的字符串
Please input something: string                   # 输入字符串:string
>>>
>>> print a                                      # 上边的输入 string 已经赋值给变量 a
string
  • chr()unichr():chr 接受一个ASCII 码,即 0-255 之间的整数,返回对应的字符。unichr 则接受一个 Unicode 码,返回对应的 Unicode 字符

  • ord():ord 作为 chr 和 unichr 的对应函数,返回一个字符的 ASCII 或 Unicode 数值

>>> chr(97)
'a'                                        # 接受一个 0-255 的整数,返回对应的ASCII 字符
>>> unichr(1234)
u'u04d2'                                  # 接受一个 0-65535 的整数,返回对应的Unicode 码
>>> print unichr(1234)
Ӓ
>>> ord('a')
97                                         # 接受一个 ASCII 字符,返回对应的数值
>>> ord(u'u04d2')
1234                                       # 接受一个 Unicode 字符,返回对应的数值
  • str()unicode():将参数转换为字符串或 unicode 字符串
>>> str(123)
'123'                                      # 将数字 123 转换为字符串
>>> unicode(123)
u'123'                                     # 将数字转换为 unicode 字符串

type(ret) #type 返回该类型

'I like python'

          #打印出a元组中最后一个元素,len()函数将得到a元组元素的个数,因为索引是从0开始的,所以元素个数减一,就是最后一个元素的索引号
          >>> print(a[len(a)-1])
          5

比C简单的多,数字只有4种类型,分别是 int, float, bool, complex,纳尼?还有复数。

8. 字符串内建函数

  • string.strip():删除 sting 字符串开头和末尾的空格

a = 'tstringn'
a.strip()
'string' # 将字符串前后空格都删除,lstrip() 和 rstrip() 分别删除开头和结尾的空格
```

  • string.split(str):以 str 为分隔符将字符串进行分隔

a = 's t r i n g'
a.split(' ')
['s', 't', 'r', 'i', 'n', 'g'] # 以空格为分隔符将字符串进行分隔
```

  • string.join(seq):以 string 为分隔符,将 seq 中的所有元素合并为一个新的字符串

a = ['s', 't', 'r', 'i', 'n', 'g']
' '.join(a)

>>> print a # 上边的输入 string 已经赋值给变量 a
string
- __chr()__ 和 __unichr()__:chr 接受一个ASCII 码,即 0-255 之间的整数,返回对应的字符。unichr 则接受一个 Unicode 码,返回对应的 Unicode 字符 - __ord()__:ord 作为 chr 和 unichr 的对应函数,返回一个字符的 ASCII 或 Unicode 数值
>>> chr(97)
'a' # 接受一个 0-255 的整数,返回对应的ASCII 字符
>>> unichr(1234)
u'u04d2' # 接受一个 0-65535 的整数,返回对应的Unicode 码
>>> print unichr(1234)
Ӓ
>>> ord('a')
97 # 接受一个 ASCII 字符,返回对应的数值
>>> ord(u'u04d2')
1234 # 接受一个 Unicode 字符,返回对应的数值
- __str()__ 和 __unicode()__:将参数转换为字符串或 unicode 字符串
>>> str(123)
'123' # 将数字 123 转换为字符串
>>> unicode(123)
u'123' # 将数字转换为 unicode 字符串
### 8. 字符串内建函数 - __string.strip()__:删除 sting 字符串开头和末尾的空格
>>> a = 'tstringn'
>>> a.strip()
'string' # 将字符串前后空格都删除,lstrip() 和 rstrip() 分别删除开头和结尾的空格
- __string.split(str)__:以 str 为分隔符将字符串进行分隔
>>> a = 's t r i n g'
>>> a.split(' ')
['s', 't', 'r', 'i', 'n', 'g'] # 以空格为分隔符将字符串进行分隔
- __string.join(seq)__:以 string 为分隔符,将 seq 中的所有元素合并为一个新的字符串
>>> a = ['s', 't', 'r', 'i', 'n', 'g']
>>> ' '.join(a)
's t r i n g' # 用空格将 a 中的元素合并成新的字符串
''.join(a)
'string' # 当不指定 string 时,直接合并
```

  • string.find(sr):检测 str 是否在字符串中,如果时返回索引,否则返回 -1

a = 'strings'
a.find('s')
0 # 结果总是返回第一个找到的索引
a.find('a')
-1 # 没有找到时返回 -1
```

  • string.index(str):与 find 类似,但不存在时引发一个异常

a = 'strings'
a.index('s')
0 # 同样返回第一个 str 的索引
a.index('a') # 与 find 不同,str 不存在时引发一个异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: substring not found
```

  • string.count(str):返回 str 在字符串中出现的次数

a = 'strings'
a.count('s')
2
```

  • string.upper()string.lower():分别将字符串字符转换为大写和小写
>>> a = 'String123'
>>> a.upper()
'STRING123'                             # 将字符串 a 中的所有字母大写,非字母不变
>>> a.lower()
'string123'                             # 将字符串 a 中的所有字母小写,非字母不变
  • string.partition(str):find() 和 split() 的结合,从 str 出现的第一个位置起,将 string 分成三元组 (string_pre_str, str, string_post_str), 如果不包含 str,string_pre_str = string

a = 'string'
a.partition('r')
('st', 'r', 'ing')
a.partition('a')
('string', '', '')
```

  • string.replace(str1,str2) :把 str1 替换为 str2

a = 'strings'
a.replace('s', 'x')
'xtringx' # 把 string 中所有的 str1 替换为 str2,可以指定替换的次数参数
a.replace('a', 'x')
'string' # string 中不包含 str1 时,不做任何操作
```

更多关于字符串的内建函数参考:String Method

查看对象的类,或所具有的功能

关于类似的操作,还有很多变化,比如输出格式要宽度是多少等等,找了一个参考图,你看看开心就好

          #另一种简便的获取元组中最后一个元素的方法,直接使用-1,以此类推,获取倒数第二个元素就使用-2作为索引值
          >>> print(a[-1])
          5
          >>> print(a[-2])
          4

int就是长整型,没有c里面的短整型一说。看到了吧,随着计算机硬件的强大,过去无比宝贵的内存资源已经不稀罕了,怎么对程序员方便友好怎么来,这也是现代语言的一个基本设计思想。

9.字符串格式化

Python 中的字符串格式化操作,类似于 C 语言中的 printf() 函数的字符串格式化,语法如下:

  1. 在 % 操作符的左侧放置一个需要进行格式化的字符串,这个字符串带有一个或多个嵌入的转换目标,都以 % 开头。

  2. 在 % 操作符的右侧放置一个或多个(元组)对象,这些对象会插入到左侧需要进行格式化的一个或多个转换目标的位置上去。

>>> "That is %d %s bird!" % (1, 'little')
That is 1 little bird!

在上边这个例子中,整数 1 替换在格式化字符串左侧的 %d, 字符串 'little' 替换 %s,从而得到一个新的格式化了的字符串。

如果不使用格式化字符串,我们可以使用多次字符串的合并和转换来达到目的,但十分麻烦。

>>> "That is "   str(1)   " little " "bird !"
That is 1 little bird!

通常根据需要转换的目标不同,左侧 % 操作符后边的符号也不相同,常见的格式化代码如下

代码 意义
%s 字符串
%r 使用 repr 的字符串
%d 十进制整数
%i 整数
%f 浮点十进制数

从高级的应用来说,表达式左侧的转换目标有一套完整的语法:

     `%[(name)][flag][width][.precision]typecode`

上表中的字符码出现在目标字符串的尾部,在 % 和字符码之间,可以有以下操作:

  • 放置一个字典的键 [(name)]
  • 列出左对齐 -、正号 和补零 0 的标志位 [flag]
  • 给出数字的整体长度和小数点后的位数等 [width] [.precision]
>>> "***%d***%-6d***d***% d***" % (123, 123, 123, 123)
'***123***123   ***000123*** 123***'                           # %-6d 表示左对齐,d 表示补零

>>> "***%.2f***" % (123.456)
***123.46***                                                    # %.2f 表示保留浮点数小数点后2位

>>> "That is %(number)d little %(name)s !" % {'number':1, 'name':'bird'}
That is 1 little bird !                                         # 使用字典进行格式化

format() 方法:在 Python 2.6 和 3.0 以后的版本引入了一种新的格式化方法,format() 函数

>>> "That is {0} little {1} !".format(1, 'bird')
That is 1 little bird !
  • 格式化总是会返回新的字符串作为结果而不是对左侧的字符串进行修改,如果需要的话,必须将格式化字符串赋值给一个变量来保存结果。

  • 更多关于字符串格式化的参考:String format

更多关于字符串的参考:Sequence Type

temp="alex"
t=type(temp)
print(t)
#str,ctr 鼠标左键,找到str类,内部所有的方法

图片 1

          #获取多维元组中,第0个元素(a元组)中索引位置为2的值,也就是a子元组中的3了
          >>> print(c[0][2])
          3
0×2.列表

 

temp="alex"
b=dir(temp) #快速看看这个类的所有方法

split   这个函数的作用是将字符串根据某个分割符进行分割

python中,可以使用中括号创建列表,在上面的元组实例中的大部分操作都适用于列表,只需要将圆括号替换成中括号即可,不同点是,列表中仅包含一个元素时,不需要在末尾添加逗号,另外,列表可以添加或删除元素,请看下面的实例:

用type()和isinstance()都可以得知某个变量所指向的对象的类型。区别是,type()比较死脑筋,但是isinstance()会认为子类是一种父类类型。即:isinstance(子类型) == 父类型 会返回True

基本数据类型常用功能

>>> a = "I LOVE PYTHON"

#创建三个列表,其中c为多维列表,包含a和b
          >>> a=[1,2,3,4,5]
          >>> b=["www.qingsword.com"]
          >>> c=[a,b]

 

a=1 #声明一个变量 值为1 动态变量 可以随时更改变量类型
b="abc你好" #定义一个字符串
c="bc"
print (b)
ret="bc" in c #代表 字符串"bc" 是否在c 变量中 在true 不在false
print (ret)

>>> a.split(" ")

          #打印出三个列表中的元素
          >>> print(a)
          [1, 2, 3, 4, 5]
          >>> print(b)
          ['www.qingsword.com']
          >>> print(c)
          [[1, 2, 3, 4, 5], ['www.qingsword.com']]

既然提到了True和False,就说一下,Python3里,True和False是关键字,值分别是1和0。你可以试着print(True 1),结果是2。

temp="asd";

['I', 'LOVE', 'PYTHON']                  (这是用空格作为分割,得到了一个名字叫做列表(list)的返回值)

          #使用list.append()方法,给a列表添加一个元素6
          >>> a.append(6)
          >>> print(a)
          [1, 2, 3, 4, 5, 6]

 

print(type(temp));#可以获取到类型
print(dir(temp));#可以快速获取类型的所有方法
al="alex";
ret=al.capitalize();#将第一个字符变成大写
print(ret);
al="alex";
ret=al.center(20,'*') #让字符串居中,两侧以指定字符填充,加上填充字符一共
筹齐给定的数字长度,这里给定的是20,注意要指定单个字符,不能是字符串
print(ret);

>>> b = "www.itdiffer.com"

          #append()方法一次只能添加单个元素,而list.extend()方法一次可以添加多个元素
          >>> a.extend([7,8,9])
          >>> print(a)
          [1, 2, 3, 4, 5, 6, 7, 8, 9]

数值运算符方面,大部分和c很像,少部分的不一样,确切的说,是更便利了。比如2/4的结果是0.5,Python会自动按浮点数计算。这样写在c里面就等于0了,要想得到0.5还得强制转换类型。那么,如果就是要取整怎么办,可以写成 2//4,结果是0。 //作为运算符,也决定了不能像c里面一样用它做单行注释。

al="alexaa"
print(al.count('a'));#查找一个字符或字符串 在一个字符串出现的次数
print(al.count("a",4));#查找一个字符或字符串 在一个字符串哪个位置之后出现
的次数
temp="hello"
print(temp.endswith('o')) #判断一个字符串是否是以给定的字符或字符串结尾的
print(temp.endswith('e',0,2)); #判断获取字符串里大于等于0的位置,小于2的
位置 的结尾字符
print(temp.startswith(('h')));#判断是否一个字符开头
content="hellot999"
print(content.expandtabs(20))#实验看下吧 就是把tab或者t转换成20个空格

>>> b.split(".")

          #利用extend()方法的特性,可以将一个列表中的元素完全复制给另外一个列表,下面创建了一个空列表d,然后将c列表中的元素复制给d
          >>> d=[]
          >>> d.extend(c)
          >>> print(d)
          [[1, 2, 3, 4, 5, 6, 7, 8, 9], ['www.qingsword.com']]

乘方是 a**b,不需要像c一样调用另外的函数库。

print(content.__len__())#输出字符串长度
s="hello 9999";
print(s.find("h"));#给定字符寻找 在该字符串所在的位置,没有返回-1

['www', 'itdiffer', 'com']                   (这是用"."作为分割,得到了一个名字叫做列表(list)的返回值)

          #使用list.remove()方法可以删除列表中的元素,这个方法接收的不是索引值,而是元素值(本例直接删除了a列表中的元素1和2)
          >>> a.remove(1)
          >>> a.remove(2)
          >>> print(a)
          [3, 4, 5, 6, 7, 8, 9]

 

s="hello{0},age{1}" #python 也有占位符
print(s)
new1=s.format('alex',19) #format可以给占位符赋值
print(new1)
a="alex9"
print(a.isalnum())#判断字符是否是数字和数字
print(a.isalpha());#判断字符串是否都是字母
print(a.isdigit());#判断是否都是数字
print(a.islower());#判断是否都是小写
print(a.isspace());#判断是否是空格
print(a.istitle())#判断是否是标题,首字母大写
print(a.isupper());#判断是否都是大写
li=["alex","eric"]
s="-".join(li) #将列表,元组,或数组(有数组么?)以给定字符连接到一起
print(s)
print(s.ljust(20,'*'))#字符串左对齐,右边填充给定字符,也可不给定

String.strip() 去掉字符串的左右空格

          #list.pop()方法接收一个索引值,如果不指定索引值则默认为最后一位元素的索引值,这个方法将取出对应元素,然后从列表中删除这个元素
          >>> print(a.pop())
          9
          >>> print(a)
          [3, 4, 5, 6, 7, 8]
          >>> print(a.pop(0))
          3
          >>> print(a)
          [4, 5, 6, 7, 8]

 

s=" alex "
news = s.lstrip() # 移除左边的空格
print(news)
print(s.rstrip())#移除右边的空格
print(s.strip())#移除左右两边空格
s="alex sb alxx"
ret=s.partition('sb') ##将字符串分割拆分 成一个元组
print(ret)

String.lstrip() 去掉字符串的左边空格

          #使用set()能够删除列表中的重复值
          >>> e=["a","a","b","c","b"]
          >>> print(e)
          ['a', 'a', 'b', 'c', 'b']

字符串:

s="alex sb alxx"
ret=s.replace("al","bb")##将字符串中的某些字符替换 返回新的字符串
print(ret)

String.rstrip() 去掉字符串的右边空格

          >>> e=set(e)
          >>> print(e)
          {'a', 'b', 'c'}
0×3.字典

字符串用单引号(')或双引号(")括起来。我喜欢单引号,因为不用按shift,便捷高效。

s="alexalex"
ret=s.split("e",1) #根据给定字符 将字符串分割成列表 可以加入第二个参数 分
割几次
print(ret)

String.upper() #String中的字母大写

python中,使用大括号能够创建字典,字典中每个元素都是以"键值对"的形式储存的,请看下面的实例:

按照老规矩, 表示转义,如果在字符串前加大写或者小写的R,就不再转义。

 

String.lower() #String中的字母小写

#有两种方法可以创建字典,第一种直接创建一个空的字典,然后逐个添加键值
          >>> a={}
          >>> a["早餐"]="牛奶鸡蛋"
          >>> a["午餐"]="可乐牛排"
          >>> a["晚餐"]="水果沙拉"
          >>> print(a)
          {'早餐': '牛奶鸡蛋', '晚餐': '水果沙拉', '午餐': '可乐牛排'}

字符串连接用 号,复制字符串N次用*号。

s="alexalex"
print(len(s)) #可以获取字符串的长度
print(s[0]) #根据索引获取字符
print(s[1])

String.capitalize() #首字母大写

          #第二种方法创建字典,一次性添加所有的键值,用冒号分隔每一组元素,冒号前为"键",冒号后为"值""
          >>> a={'早餐': '牛奶鸡蛋', '晚餐': '水果沙拉', '午餐': '可乐牛排'}

字符串截取用 变量[下标1,下标2]的形式,下标索引从0开始,末尾位置记为-1,是个左闭右开的区间,[ )。

print(s[0:2]) # 切片 获取字符>=0 <2 之内的
for temp in s:
print(temp)

String.isupper() #String中的字母是否全是大写

          #python允许不同的键拥有相同的值,所以下面的语法是正确的
          b={"one":"qing","two":"qing"}

示例速查:

####列表####
name_list=['a','bxs','ccc']
#索引
print(name_list[0])
#切片
print(name_list[0:2])
#len
print(name_list[0:len(name_list)])

String.islower() #String中的字母是否全是小写

          #有两种方法可以读取字典中的值,直接使用"字典[键]"来读取值,或使用"字典.get(键)"来读取值
          >>> print(a["早餐"])
          牛奶鸡蛋
          >>> print(a.get("午餐"))
          可乐牛排

 

#for
for i in name_list:
print(i)

String.istitle() #String中字符串中所有的单词拼写首字母是否为大写,且其他字母为小写

          #读取字典keys和values列表
          >>> print(a.keys())
          dict_keys(['早餐', '晚餐', '午餐'])
          >>> print(a.values())
          dict_values(['牛奶鸡蛋', '水果沙拉', '可乐牛排'])
0×4.数据分片实例

str = 'Runoob'

#列表内部提供的功能
#append追加

join拼接字符串

在python中能够通过数据分片,实现读取某段字符串中单个字符的目的,这种思想同样适用于元组和列表,如果列表中储存的为字符串,就可以通过分片技术取出某个元素的第几个字符,这种方法在某些环境中会非常实用,请看下面的实例:

print (str) # 输出字符串 Runoob
print (str[0:-1]) # 输出第一个到倒数第二个的所有字符 Runoo
print (str[0]) # 输出字符串第一个字符 R
print (str[2:5]) # 输出从第三个开始到第五个的字符 noo
print (str[2:]) # 输出从第三个开始的后的所有字符 noob
print (str * 2) # 输出字符串两次 RunoobRunoob
print (str "TEST") # 连接字符串 RunoobTEST

name_list.append("dddd")
name_list.append("dddd")
name_list.append("dddd")
print (name_list)
##count 查询一个元素在列表中个数
num=name_list.count("dddd")
print(num)

>>> b='www.itdiffer.com'

#首先来看python对字符串数据的分片提取方法,本例取出a指向的字符串数据中,索引位置为2的单个字符
          >>> a="abcdefg"
          >>> print(a[2])
          c

 

##extend 将一个列表插入到这个列表尾部
temp=[11,22,113,33,44]

>>> c = b.split(".")

          #在列表数据中,可以将每个字符串元素看做一个子列表,使用多维列表的思想,提取子列表中对应索引位置的值
          >>> b=["www.qingsword.com","abcdefg","12345678"]
          >>> print(b[0][4])
          q

不能给字符串中的单个字符赋值, str[1]='a'会出错。

name_list.extend(temp)

>>> c

          #提取b中索引位置为2的元素的最后一位字符
          >>> print(b[2][-1])
          8
使用字符串分片技术,将一组列表中的每个元素的首字母提取出来作为字典的键,并对应这个元素的值,下面是一段比较完整的程序:

另外,Python没有c语言的字符类型char。

print (name_list)

['www', 'itdiffer', 'com']

#!/usr/bin/env python3
          #创建一个名称列表
          a=["Qingsword","John","Tom","George","Kali","Eva"]
          x=0
          #创建一个空字典
          b={}
          #当x值小于a列表元素个数时循环
          while x<len(a):
              b[a[x][0]]=a[x]
              x =1  
          print(b) 

完全可以理解。之前说了,什么时代了,还省啥内存啊,怎么方便怎么来。

##index 查找列表中一个元素 并返回他的索引下标
index=name_list.index(11)
print(index)

>>> ".".join(c)

          #程序输出
          {'E': 'Eva', 'G': 'George', 'Q': 'Qingsword', 'K': 'Kali', 'J': 'John', 'T': 'Tom'}
除了上面介绍的简单切片技术外,python还提供了一种特殊的切片技术,分号切片,请看下面的实例:

 

##insert 在这个列表指定的下标位置插入一个元素 原下标位置以后元素 向后移
name_list.insert(1,'SB')

'www.itdiffer.com'

#分号切片同样适用于字符串或元组列表,语法为"[起始索引:结束索引(不包含)]"

 

print(name_list)

>>> "*".join(c)

          #从字符串a索引为2(3)的位置开始切片,直到索引6(7)的位置,截取这其中的数据输出(包含起始索引值,不包含结束索引值)
          >>> a="123456789"
          >>> print(a[2:6])
          3456

列表:

##pop 将列表中一个元素(可以指定索引下标,默认不设置参数是最后一个)移除掉 并返回这个元素

'www*itdiffer*com' 

          #从b中索引为3(d)的位置开始,直到索引为5(f)的位置
          >>> b=["a","b","c","d","e","f","g"]
          >>> print(b[3:5])
          ['d', 'e']

列表的定义是 listA = [x, xx,xxx] ,方括号包起,逗号隔开,乍看起来像c语言里的数组,但其实不一样。从append()、pop()等方法来看,又像是java里面的数组。我姑且认为Python里面的列表是一种混合动力加强版的数组吧,可操纵性简直逆天。看例子:

a=name_list.pop(0);

列表

一些用逗号分隔而有序的数据,用方括号表示一个list,[ ] 在方括号里面,可以是int,也可以是str类型的数据,甚至也能够是True/False这种布尔值 ['2',3,'北京图灵','outman']

bool()是一个布尔函数,这个东西后面会详述。它的作用就是来判断一个对象是“真”还是“空”(假)

列表可以索引和切片,前面字符串我好像啰嗦过了,都是一样的

这里拓展下 双冒号使用,其实Python序列切片地址可以写为[开始:结束:步长],那么其中的开始和结束省略,就出现双冒号了

开始start省略时,默认从第0项开始。结尾省略的时候,默认到数组最后。步长step省略默认为1。当step等于负数的时候,从右向左取数

>>> alst = [1,2,3,4,5,6]

>>> alst[::-1]       #从右向左取数(反转过来了)

[6,5,4,3,2,1]

上面反转我们可以用reversed函数 

>>> list(reversed(alst))

[6,5,4,3,2,1]

好了下面我转用anaconda 里面的 jupyter打命令演示了(之前是在官方python3.7)没有 >>> 

``append()方法在列表的末尾添加一个元素   

s = [1,'a','3']
s.append('t')
print(s)

[1, 'a', '3', 't']

insert()任意位插入一个元素 (说到位置,你想到什么?没错,就是索引)

s = [1,'a','3']
s.insert(3,'t')       #在索引为3的位置加字符t,也就是字符串3后边
print(s)

[1, 'a', '3', 't']

使用del语句删除元素

motorcycles = ['honda', 'yamaha', 'suzuki']
del motorcycles[0]
print(motorcycles)
['yamaha', 'suzuki']

pop()弹出任意位置一个元素       (同样说位置,还是用索引,弹出?就是拿出来)

motorcycles = ['honda', 'yamaha', 'suzuki']
motorcycles.pop(1)       #括号内不填写默认为0,经常弹出的这个值我们会用到,这就是特殊的地方
print(motorcycles)
['honda', 'suzuki']

remove()不知道要从列表中删除的值所处的位置,只知道要删除的元素的值。(知道你要删除啊啥,这就够了)

motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']
motorcycles.remove('ducati')
print(motorcycles)
['honda', 'yamaha', 'suzuki']

好了,再说几个,不做命令演示了

list.clear()    从列表中删除所有元素。相当于 del a[:]

list.index(x)   返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误

list.count(x)    返回 x 在列表中出现的次数

Python中元组列表与字典学习笔记,零基础Python知识点回顾。list.sort()    对列表中的元素就地进行排序

list.reverse()    就地倒排列表中的元素

list.copy()    返回列表的一个浅拷贝。等同于 a[:]      说说这个吧,你可能会问啥是浅拷贝?演示代码给你看下,你会发现确实新拷贝的列表ID不一样,但里面元素ID一样

b = ['honda', 'yamaha', 'suzuki']
a = b.copy()
print(id(b))           #查看列表b的ID
print(id(b[1]))       #查看列表b中索引值为1的元素ID
print(a)
print(id(a))           #查看列表a的ID
print(id(a[1]))       #查看列表a中索引值为1的元素ID
99833224
99844368
['honda', 'yamaha', 'suzuki']
105157704
99844368

list.extend(b)      将一个给定列表中的所有元素都添加到另一个列表中,相当于 a[len(a):] = b 这个理解么?就是说列表a其切片从索引值"len(a)"到结束的部分就是列表b
a = [1, 2, 3]
b = ['qiwsir', 'python']
a.extend(b)
print(a)
[1, 2, 3, 'qiwsir', 'python']                    这里你想下和append()的区别

 

说到这,就不得不深入下,extend函数也是将另外的元素增加到一个已知列表中,其元素必须是iterable,什么是iterable?也就是可迭代

迭代是重复反馈过程的活动,其目的通常是为了接近并到达所需的目标或结果

hasattr()的判断本质就是看那个类型中是否有__iter__函数。可以用dir()找一找,在数字、字符串、列表、元组、集合、字典,谁有__iter__(截图了,打命令好累)

图片 2为什么?数字你搞什么!

那我们想下,列表都干啥用呢?

1. 把列表当作堆栈使用

列表方法使得列表可以很方便的做为一个堆栈来使用,堆栈作为特定的数据结构,最先进入的元素最后一个被释放(后进先出)。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来

2. 把列表当作队列使用

可以把列表当做队列使用,队列作为特定的数据结构,最先进入的元素最先释放(先进先出)。不过,列表这样用效率不高。相对来说从列表末尾添加和弹出很快;在头部插入和弹出很慢(因为,为了一个元素,要移动整个列表中的所有元素)

3. 列表推导式(可嵌套)

列表推导式为从序列中创建列表提供了一个简单的方法。普通的应用程式通过将一些操作应用于序列的每个成员并通过返回的元素创建列表,或通过满足特定条件的元素创建子序列

 

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print (a)
print(name_list)

print (list) # 输出完整列表 ['abcd', 786, 2.23, 'runoob', 70.2]
print (list[0]) # 输出列表第一个元素 abcd
print (list[1:3]) # 从第二个开始输出到第三个元素 [786, 2.23]
print (list[2:]) # 输出从第三个元素开始的所有元素 [2.23, 'runoob', 70.2]
print (tinylist * 2) # 输出两次列表 [123, 'runoob', 123, 'runoob']
print (list tinylist) # 连接列表 ['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

##remove 移除指定元素

和字符串不能改变其中的元素不同,列表里面的可以改,而且简直是随便改,不要太方便。

name_list.remove("SB")
print(name_list)

a = [9, 2, 13, 14, 15, 6]
a[2:5] = [] # 将对应的元素值设置为 []
print(a) # 结果是 [9, 2, 6]

##reverse 将列表元素翻转
name_list.reverse();
print(name_list)

 

 

元组(Tuple)

此物老夫从未见过。特地去搜索了一下,Tuple这个词似乎是Python特有的,不像list之类的词在生活中还有别的含义。只好认真看教程了。

 

教程里解释:

元组写在小括号(())里,元素之间用逗号隔开,只有一个元素时,唯一的元素后面要加逗号。

元组(tuple)与列表类似,不同之处在于元组的元素不能修改。

 

类似列表?行了,翻页。

 

集合:

存放无序不重复元素的序列,用于进行成员关系测试和删除重复元素。

重点:1)无序;2)不重复。

 

用{}或者 set() 函数创建集合。 setA = {'hatemath'} 或者 setA = set('hatemath')

注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。

常见集合运算有:并集 |, 差集 - ,交集&, 不同时存在的元素集 ^ (按我理解就是并集减去交集)

 

例子:

a = set('hate')
b = set('math')

print(a | b)      # {'t', 'm', 'a', 'e', 'h'}
print(a - b)      # {'e'}
print(a & b)      # {'a', 't', 'h'}

print(a ^ b)      # {'m', 'e'}
print( (a | b) - (a & b))      # {'e', 'm'} 果然就是我理解的意思。

 

集合,很好很强大。再见。

 

肚子饿了。。。15年前初学编程的时候,经常去计算中心上机,为了debug经常错过饭点,而且把零钱用光了。下机后跑去跟老板赊账吃饭(此处应该有个笑哭的表情)。过了这么多年还是喜欢编程,看来是真爱。

也有可能是因为我没把它当做谋生的手段。

 

字典:

字典是无序对象的集合,其中的元素时通过键(key)来存取的,取出来的叫值(value)。眼熟!java里面有这个玩意。我发现学这些高级特性的时候,跟c基本没啥关系了。。。。

既然是熟人,就直接看例子吧。

 

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"

tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}

print (dict['one']) # 输出键为 'one' 的值        1 - 菜鸟教程
print (dict[2]) # 输出键为 2 的值             2 - 菜鸟工具
print (tinydict) # 输出完整的字典        {'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}
print (tinydict.keys()) # 输出所有键     dict_keys(['name', 'site', 'code'])
print (tinydict.values()) # 输出所有值  dict_values(['runoob', 'www.runoob.com', 1])

 

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:Python中元组列表与字典学习笔记,零基础Python知

关键词: