第二天：数值与字符串、列表list

数值

1、 声明变量

age = 20
f = 3.14 #浮点型
f = 0.3
f = .3

2、表达式

• 主要是做一些简单的加减乘除运算，直接出结果

1.1 + 2.2
2.2 + 3.0
3.14 * 2
5.0 / 2 

3.3000000000000003
5.2
6.28
2.5

在上面的实例中，主要是要看到简单的‘1.1+2.2’在python中的输出结果并不像我们想象中的简单的3.3，而是一个有很长小数位数的'3.3000000000000003'。

3、显示(使用.format()来替换字符)

• eg:'{0:.2f}'.format(3.3333)

'{0}'.format(20)
'3 + 2 ={0}'.format(5)
f = 3.333
'f = {0}'.format(f)
'f={0:.2f}'.format(f)
d = {'name':'Tom', 'age':20, 'job':'dev'}
'姓名:{0},年龄:{1}'.format(d.get('name'), d.get('age'))

上面的代码输出如下：

'20'
'3 + 2 =5'
'f = 3.333'
'f=3.33'
'姓名:Tom,年龄:20'

在上面的实例中我们看到了.format()的强大之处，可以动态替换已有字符串中的字符，同时我们还可以通过在{0}中加入':.2f'来规定需要加入的数值型对象的数据类型与保留的小数点位数。

4、比较，返回布尔型结果：True, False

• 常用运算符 >, <, >=, <=, ==, !=

5、相除

10 / 4
10 // 4
10 // 4.0

输出如下：

2.5
2
2.0

上面的第一个是平时使用的正常除法，后面的是常见的“地板除”，也叫整除，得出的是商（不含余数）。
第三个除式是为了得到浮点型的结果。

6、取整的三个方法

• floor()、trunc()、round()
  • floor()取整

  import math
  math.floor(3.4)  # 取整的函数,直接截取整数
  math.floor(3.9)
  math.floor(-3.4)
  math.floor(-3.9)  # 假如把数值放在坐标轴上，那么floor是取数值左边的整数，往左移动坐标轴

  3
  3
  -4
  -4

  • trunc()取整

  math.trunc(3.14) # tuanc函数是往坐标轴0中间移动
  math.trunc(3.94)
  math.trunc(-3.14)
  math.trunc(-3.94)

  3
  3
  -3
  -3

  • round()取整

  round(3.14) #常规意义上的四舍五入
  round(3.94)
  round(-3.14)

  3
  4
  -3
  -4

  7、整型：无限精度，仅受限于内存与计算机精度

• 十六进制0o、八进制0x、二进制0b
  • 八进制0o

  0o3  # 0o开头表示八进制，但是八进制只能表示0-7
  0o7
  0o8 # 报错

  3
  7

  • 十六进制0x

  0x3 #十六进制
  0x9
  0xa
  0xf

  3
  9
  10
  15

  • 二进制0b

  0b1 # 二进制
  0b0
  0b11
  0b1011

  1
  0
  3
  11

• 转换进制的几个函数

oct(64) # 转换64进制的写法
hex(64) # 十六进制的写法
bin(64) # 二进制的写法

'0o100'
'0x40'
'0b1000000'

• 其他琐碎

math.pi # math里内置的一些函数
math.sqrt(144)

3.141592653589793
12.0

• 关于decimal

import decimal
decimal.Decimal('3.14')
decimal.Decimal('1.1')+decimal.Decimal('2.2')  # 得到需要的精度

Decimal('3.14')
Decimal('3.3')

字符串

1、声明

• ''
• ""
• """##""" 说明性的文档
  对于字符串中的引号处理问题可以参考一下方法

word = "What's your name?"
word
'what\'s your name?'

"What's your name?"
"what's your name?"

2、转义符

• 转义符
  

    \ 
    \'    
    \"    

• 换行符 \n
• 退格键 \b
• 表格四个空格 \t
• 忽略转义符 r'...'
  直接写明路径会有报错：

path = 'C:\abc\xyz.txt'

SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 6-7: truncated \xXX escape

可以用下面的方法来转移“”

path = 'C:\\abc\\xyz,txt'
path

'C:\\abc\\xyz,txt'

最好是用忽略转义符：

path = r'c:\abc\xyz.txt'
path

'c:\\abc\\xyz.txt'

可以使用"""##"""在代码中注释：

def avg():
    """计算平均分"""
    pass
# 这是一行注释

3、基本操作

name = 'tom'
len(name)
'abc' + 'xyz'
'ok' * 5
print('-' * 30)

3
'abcxyz'
'okokokokok'
------------------------------

• 假如我想要逐字打印呢，可以这样：

s = 'hello'
for c in s:
    print(c)

h
e
l
l
o

• 想要在逐字中间加点东西？：

for c in s:
    print(c, end = ' ')

h e l l o 

• 想要调用字符串中的某个字段：

s[0]
s = 'sfdsfsfsdf'
s[0:4] # 后面的数字坐标是不包括的，不会引用出来

'h'
'sfds'

• 调用最后一个字段的两个方法

s[-1]
s[len(s)-1]

'f'
'f'

• 花式调用：

s[:]
s[::2] # 以2作为间隔获取
h = 'hello'
h[::-1]
int('42')+1 # 使得字符串与数字相加

'sfdsfsfsdf'
'sdffd'
'olleh'
43

• 关于ASCII表

ord('c') # 查看ascii表里位置
chr(99) #查看相应位置对应的字符
chr(75)

99
'c'
'K'

• 使用replace()替换字符串的某个字段

h = 'hello'
h = h.replace('e', 'a')
h

'hallo'

4、布尔型

• True、False

type(True)  # 区分大小写
type(3)
isinstance(True, int) # 这个函数是判断某个字符是否是某个类型
True == 1
False == 0
result = True + 3
result

bool
int
True
True
True
4

5、基本骚操作

• 通过列表作为中介来改变字符串中的某一个字段
  • 先把字符串变成列表

  s = 'sdhishd.com'
  l = list(s)
  l

  ['s', 'd', 'h', 'i', 's', 'h', 'd', '.', 'c', 'o', 'm']

  • 替换列表中的字段

  l[len(l)-1] = 'c'  # 或者可以用 l[-1] = 'c'
  l

  ['s', 'd', 'h', 'i', 's', 'h', 'd', '.', 'c', 'o', 'c']

  • 再变成字符串

  s = ''.join(l) #通过一个空的字符串
  s

  'sdhishd.coc'

  s = '|'.join(l) #将字符串中的每一个字段都用符号隔开
  s
  url = 'sadfhsk.com,sdfjl.cc,sfhioho.com'  # 使用逗号隔开字符串中的字段，前提是知道字符串中存在的分隔符
  l = url.split(',')
  l

  's|d|h|i|s|h|d|.|c|o|c'
  ['sadfhsk.com', 'sdfjl.cc', 'sfhioho.com']

• len(l) # 这其实是一个函数，不依附于对象
• s.split() # 这是一个方法，是python在定义字符串类型时就设置好的方法。

url = 'sdfi.cc'
url.startswith('url') # 判断字符串的开头方法
url.endswith('cc') # 判断字符串结尾的方法
url.find('sdf') # 返回字段在字符串中的位置，返回寻找字段首字符位置
url.find('.')

False
True
True
0
4

• 关于赋值

a,b = 1,2
a
b

1
2

a,b = b,a #交换对象
a
b

2
1

- 交换过程的展示

'{0} = > {1}'.format(a, b) #交换的过程表示
'{} = > {}'.format(a, b)  #也可以不写索引
'{name}=>{salary}'.format(salary = 9000.00,name = 'Tom' ) 
#可以不按顺序，但是要指定变量与对象
url.upper() #大写变量

'2 = > 1'
'2 = > 1'
'Tom=>9000.0'
'SDFI.CC'

列表

• 任意对象的有序集合
• 通过索引下标访问元素
• 可变长度
• 属于可变序列
• 常用操作：

len([3, 4, 5]) #求列表长度的时候，会计算列表中的对象数量
[1,2,3]+[3,4,5]
l = list('dfasihdi') #这里的list是个函数，要用小括号
l
'k' in l

3
[1, 2, 3, 3, 4, 5]
['d', 'f', 'a', 's', 'i', 'h', 'd', 'i']
False

for c in l:
    print(c)
for c in l:
    print(c,end = '|')

d
f
a
s
i
h
d
i
d|f|a|s|i|h|d|i|

• append()

l = [1,2,3,4,5,6]
res = []
for i in l:
    res.append(i**2) #append方法就是扩展
    
res
l1 = [i**2 for i in l] # 外侧的中括号决定返回的是一个列表
l1

[1, 4, 9, 16, 25, 36]
[1, 4, 9, 16, 25, 36]

[c*3 for c in 'code']
l = [1,2,3]
l[1:2] = [4,5] #替换列表
l

['ccc', 'ooo', 'ddd', 'eee']
[1, 4, 5, 3]

• extend()

l.extend([9,8,5]) # 扩展一个列表，连接起来
l

[1, 4, 5, 3, 7, 9, 8, 5]

• 排序

l.sort() #正向排序
l
l.reverse() #反向排序
l

[1, 3, 4, 5]
[5, 4, 3, 1]

• 删除元素

l.pop() #删除最后一个元素
l
del(l[0])
l

[5, 4, 3]
[4,3]

l.index(5) #返回列表中元素的索引
l.count(5) #统计列表中元素5的个数

2
1

• 注意：引用类型，支持原位改变。拷贝副本，可以用：[:]，.copy()

l1 = [1,2,3,4,5]
l2 = l1
l2
l1[1] = 9 #改变l1中的元素，然后l2中相应的元素也会改变的
l1
l2

[1, 2, 3, 4, 5]
[1, 9, 3, 4, 5]
[1, 9, 3, 4, 5] #l2也跟着改变了

避免改变的方法

l3 = l1[:] #第一种避免l3改变的方法
l3
l4 = l1.copy() #使用.copy()方法
l4

[1, 9, 3, 4, 5]
[1, 9, 3, 4, 5]