一、字符串

\ 转义符

>>> worlds='hello \nshark'
>>> print(worlds)
hello 
shark

拼接

print('hello'+'lenovo')
hellolenovo

不可以用 字符串和 一个非字符串类型的对象相加

'lenovo' + 1   # 这会报错的

* 复制

>>> print('*' * 10)
**********
>>> print('lenovo 666' * 5)
lenovo 666lenovo 666lenovo 666lenovo 666lenovo 666

字符串 和 0 或者 负数相乘，会得到一个空字符串

 >>> "hey" * 0
''
>>> "hey" * -100
''

strip 移除字符串两端的字符

>>> url = 'www.hdhhd.com'
>>> url.strip('m')
'www.hdhhd.co'
>>> url.strip('w')
'.hdhhd.com'

字符串 是 Python 中的一个 序列类型 的数据结构

存放的数据，在其内是有序的，内部的数据是可以通过在其内部所处的位置进行访问等操作。

序列类型的特点:

序列里的每个数据被称为序列的一个元素;
元素在序列里都是有个自己的位置的，这个位置被称为索引或者叫偏移量，也有叫下标的;
下标索号好从 0 开始的
序列中的每一个元素可以通过这个元素的索引号来获取到
获取序列类型数据中的多个元素需要用切片的操作来获取到

获取元素

>>> sl = "shark"
>>> sl[0]
's'
>>> sl[3]
'r'
>>> sl[-1]
'k'

切片

*start 永远是起始索引号
*end 永远是终止索引号
*step 是可选的步长
分片操作只包含位于起始索引号位置的元素；不包含位于终止索引号位置的元素；
同时，起始和终止的意义都是针对于从左向右的顺序来定义的。

# 使用切片获取多个元素
>>> sl = [2,34,4,'w','e']
>>> sl[0:2]    #从0开始切两位 从左往右切片
[2, 34]
#获取字符串的长度，包含空格和换行符
>>> n = len(sl)
>>> print(n)

. split分割

默认使用 空格或者 Tab 间做为分隔符

>>> url = 'www.baidu.com 百度'
>>> url.split()   #默认以空格分割
['www.baidu.com', '百度']

>>> url.split('.') #以.来分隔
['www', 'baidu', 'com 百度']

>>> s = "symbol=BCHBTC;baseCoin=BCH;quoteCoin=BTC;"
>>> s_list = s.split(';')
>>> print(s_list)
['symbol=BCHBTC', 'baseCoin=BCH', 'quoteCoin=BTC', '']

. replit -->从右向左分割

找到第一个分隔符，就结束

>>> url
'www.baidu.com 百度'
>>> url.rsplit('.',1)
['www.baidu', 'com 百度']

. replace 替换

>>> url
'www.baidu.com 百度'
>>> url2 = url.replace('.','_')
>>> print(url2)
www_baidu_com 百度

. strip

移除字符串两端的空白字符

>>> llf = ' shark '
>>> llf.strip()
'shark'

. startswith

判断字符串以什么为开头

>>> ss = 'hello world'
>>> if ss.startswith('h'):
...     print(ss)  #条件符合才输出
... 
hello world

. endswith

判断字符串以什么为结尾

>>> ss = 'Hello World'
>>> if ss.endswith('d'):
...     print(ss)   #条件符合才输出
... 
Hello World

. index

获取一个元素在字符串中的索引号

>>> ss = 'Hello World'
>>> ss.index('e')   #索引号从0开始
1

>>> ss = 'heLLo wORLD'
>>> ss.capitalize()  #字符串的首字母变大写，其他变小写
'Hello world'

>>> ss.title()     #单词首字母大写
'Hello World'

>>> ss.upper()     #全部daxie
'HELLO WORLD'
>>> ss.lower()    #全部小写
'hello world'

交互输出

#input 接收到的结果永远是字符串类型
>>> inp = input(">>:")
>>:y
>>> print(inp)
y

>>> import getpass
>>> pwd = getpass.getpass("输入密码:")
输入密码:
>>> print(pwd)
123456

对于字符串和字节串类型来说，当且仅当 x 是 y 的子串时 x in y 为 True。
空字符串总是被视为任何其他字符串的子串，因此 "" in "abc" 将返回 True。

二、格式化输出

简单介绍

字符串的格式化输出目前有两种方式

%   方式(陈旧)
str.format()   方式(新式,官方推荐)
f-string 方式   (Python3.6 及以上推荐使用)

1、%方式

>>> llf = "I am %s" % "hello"
>>> print(llf)
I am hello
>>> llf = "I am %s age %d" % ("hello",18)
>>> print(llf)
I am hello age 18
>>> llf = "I am %(name)s age %(age)d" % {"name": "xiaoming","age":18}
>>> print(llf)
I am xiaoming age 18
>>> tpl = "percent %.2f" % 99.367378
>>> print(tpl)
percent 99.37

%[(name)][flags][width].[precision]typecode
"""
(name) 可选，用于选择指定的key
Flags 可选，可供选择的值有:
+右对齐；正数前加正号，负数前加负号；
-左对齐；正数前无符号，负数前加负号；
空格 右对齐；正数前加空格，负数前加负号；
0 右对齐；正数前无符号，负数前加负号;用0填充空白处;
width 可选，占有宽度
.precision 可选，小数点后保留的位数
typecode 必选

typecode 有以下这些：

s 获取传入对象的str方法的返回值，并将其格式化到指定位置
d 将整数、浮点数转换成 十 进制表示，并将其格式化到指定位置
f 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置 (默认保留小数点后6位）
o 将整数转换成 八进制表示，并将其格式化到指定位置
x 将整数转换成十六进制表示，并将其格式化到指定位置
% 当字符串中存在格式化标志时，需要用 %%表示一个百分号

2、str.format方式

>>> llf = "I am {},age {},{}"
>>> r = llf.format("yangge",18,'yangge')
>>> print(r)
I am yangge,age 18,yangge
>>> 
>>> a,*b = ["yangge",18,'yangge']
>>> print(a)
yangge
>>> print(b)      # *b是一个整体
[18, 'yangge']
>>> 
>>> tpl = "i am {0}, age {1}, really {0}"
>>> print(tpl.format("xiguatian", 18))
i am xiguatian, age 18, really xiguatian

3、f-string方式

f-string 也称为 格式化的字符串文字，是以f 或 F 为前缀的字符串文字。
这些字符串可能包含可被替换的字段，这些字段是由大括号 {} 分隔的表达式。
虽然其他字符串文字总是具有常量值，但格式化字符串实际上是在运行时计算的表达式。

>>> name = "天气好"
>>> age = 6
>>> s = f'今天{name}，我和{age}岁的侄子外出放风筝'
>>> print(s)
#输出
今天天气好，我和6岁的侄子外出放风筝

因为f-strings是在运行时计算的，所以可以在其中放置任何和所有有效的Python表达式

#可做简单的事情
>>> f "{2 * 37}"
74

调用函数：
>>> def to_lowercase(inp):
...     return inp.lower()
... 
>>> name = "shark"
>>> s = f"{to_lowercase(name)} is strong"
>>> print(s)
shark is strong

多行f字符串

>>> name = "shark"
>>> profession = "proter"
>>> llf = "Even though you like Python very much"
>>> message = (
...     f"Hi {name}."  #f 必须放在每一行的前面 否则不起作用！
...     f"You are a {profession}."
...     f"You were in {llf}."
... )
>>> print(message)
Hi shark.You are a proter.You were in Even though you like Python very much.

如果使用"""会是这样：

>>> message = (
...     f"""Hi {name}."
...     You are a {profession}.
...     You were in {llf}."""
... )
>>> print(message)
Hi shark."
    You are a proter.
    You were in Even though you like Python very much.

速度

在运行时，花括号内的表达式在其自己的作用域中计算，然后与 f-string 的字符串文字部分放在一起。然后返回结果字符串。

这是一个速度比较：
>>> import timeit
>>> timeit.timeit("""name = "Evev"
... age = 23
... '%s is %s.' % (name,age)""",number = 10000)
0.003299199999673874

>>> timeit.timeit("""name = "Evev"
... age = 23
... '{} is {}.'.format(name,age)""",number = 10000)
0.00406760099940584

>>> timeit.timeit("""name = "Evev"
... age = 23
... f'{name} is {age}.'""",number = 10000)
0.0019151450005665538
三者比较，f-string排在前面

4、字典

说到引号，请注意何时使用词典。如果要对字典的键使用单引号，请记住确保对包含键的f字符串使用双引号。

#一定要使用"",否则会出现语法错误
>>> info = {"name":'shark','age':18}
>>> s = f"My name is {info['name']},age is {info['age']}"
>>> print(s)
My name is shark,age is 18

大括号

>>> f"{{74}}"
'{74}'
>>> f"{{{74}}}"  #使用三重括号字符串也只有一个大括号；
'{74}'
>>> f"{{{{74}}}}" #使用三个大括号以上，将获得更多括号
'{{74}}'

流程图：Python 字符串格式经验法则

image.png
注意：如果您的格式字符串是用户提供的，请使用模板字符串（＃4）来避免安全问题。否则，如果您使用的是Python 3.6+，则使用Literal String Interpolation / f-Strings（＃3），如果不是，则使用“New Style”str.format（＃2）。

模板字符串（标准库）

这是Python中字符串格式化的另一个工具：模板字符串。它是一种更简单，功能更少的机制，但在某些情况下，这可能正是您所需要的。

示例：
>>> from string import Template
>>> name = 'shark'
>>> s = Template("hello $name")
>>> print(s)
<string.Template object at 0x7f93e6f982d0>
>>> print(s.substitute(name=name))
hello shark

那么什么时候应该在Python程序中使用模板字符串？在我看来，使用模板字符串的最佳时间是在处理程序用户生成的格式化字符串时。由于复杂性降低，模板字符串是更安全的选择

三、数据结构

一、什么是数据结构

在计算机科学中，数据结构（英语：data structure）是计算机中存储、组织数据的方式

#定义一个列表
>>> llf = [1,2,1,34,'a','f']

**len() **
方法是一个内置函数，可以统计序列类型的数据结构的长度。

>>> n = len(llf)
>>> print(n)
6

**in **
判断元素是否存在于列表中。

>>> if 2 in llf:
    print('我存在')
我存在

append()
向列表的最后位置，添加一个元素，只接收一个参数。

>>> llf = [1,2,1,34,'a','f']
>>> llf.append('hello')
>>> llf
[1, 2, 1, 34, 'a', 'f', 'hello']

insert()
向原列表的指定位置插入一个元素，接收两个参数，
第一个是索引号，第二个是要插入的元素。

>>> kk
[2, 3, 6, 7, 66, 100]
>>> kk.insert(0,'b')
>>> kk
['b', 2, 3, 6, 7, 66, 100]

extend()
可以把一个序列类型中的每个元素追加到原列表中，接收的参数是一个序列类型的数据（字符串，列表）。

>>> kk
['b', 2, 3, 6, 7, 66, 100]
>>> jj=['a','b']
>>> kk.extend(jj)
>>> li
[5, 3, 'b', 21, 11, 'a', '7', 0, 80, 'qf', 'hshjsk']

remove()
移除列表中某个指定的元素，没有返回值，并且假如有多个相同值的元素存在，每次只会移除排在最前面的那个元素

>>> kk
['b', 2, 3, 6, 7, 66, 100, 'a', 'b']
>>> kk.remove('a')
>>> kk
['b', 2, 3, 6, 7, 66, 100, 'b']

pop()
从原列表中删除一个元素，并且把这个元素返回。
接收零个或一个参数，参数是偏移量，int 类型。

>>> kk
['b', 2, 3, 6, 7, 66, 100]
>>> kk.pop()
100
>>> kk
['b', 2, 3, 6, 7, 66]

''.join() 把列表中的元素拼接起来，返回的是字符串类型

>>> l7 = ['a','b']
>>> ''.join(l7)
'ab'
>>> s='.'.join(l7)
>>> print(s)
a.b

index 返回指定元素的索引号。

>>> li = [1,2,3,4]  #索引号0，1，2...
>>> idx = li.index(2)
>>> print(idx)
1

*count() 是列表的内置方法，统计相同值的元素在列表中总共出现多少次.

>>> jj = [1,2,3,3,4,5,1,4,45,22,3,2,1]
>>> num = jj.count(1)
>>> print(num)
3

sort()
是列表的内置方法，对列表中元素进行排序。默认是升序， 这个改变列表自身。还可以接收一个 reverse (反转) 参数, 其值可以是 True 和 False。False 是升序，True 是降序。需要是同一种数据类型，比如都是字符串，或都是整型

>>> ll = [2,4,6,7,33,335,2,1,0,5]
>>> ll.sort()
>>> ll
[0, 1, 2, 2, 4, 5, 6, 7, 33, 335]
#reverse反转
>>> ll.sort(reverse=True)
>>> print(ll)
[335, 33, 7, 6, 5, 4, 2, 2, 1, 0]

sorted()
是 python 的内置函数，接受一个参数，参数可以是任意序列类型的数据，但是元素的类型必须相同.
比如是含有都是 str 的列表，或者是含有都是 int 的列表，它会返回一个新的类别，原列表不变。

>>> li = [2,10,3,7]
>>> l10 = sorted(li)
>>> l10
[2, 3, 7, 10]
>>> print(li)  #原列表不变
[2, 10, 3, 7]

二、通过索引和切片修改列表

索引号和切片

>>> int_number = [1,2,3,4,5]
>>> int_number[2]=20   #修改列表
>>> int_number
[1, 2, 20, 4, 5]

#切片修改列表
>>> li = [1,2,3,4]
>>> li[1:3] = [0]
>>> print(li)
[1, 0, 4]

引用赋值
用等号将一个列表赋值给多个变量时，使用其中任意一个变量对列表的操作，结果都会同步到其他变量的值。
在这种现象中，就像前面学到的变量的赋值，变量和列表本身之间的关系称作，变量对列表对象的引用，并没有创建一个新的列表。

>>> a = [1,2,3]
>>> b = a
>>> b
[1, 2, 3]
>>> a[-1]=5
>>> a
[1, 2, 5]
>>> b
[1, 2, 5]

解决方法
使用以下任意一种方法,都可以将原列表的值赋值给一个新的列表
列表的内置函数 obj.copy()
序列类型函数 list(obj)
列表切片
以上方法得到的列表可赋值给一个新的变量， 这变量各自有自己的列表对象，互相之间不会影响

二、深浅拷贝

In [110]: base_count = ['name'['money',100.00]]
In [111]: xmen = list(base_count)
In [112]: xpan = base_count.copy()
In [113]: xmen[1][1] = 20.00

In [114]: xpan
Out[114]: ['name', ['money', 20.0]]

image.png

解决办法：

image.png

四、元组

1、元组特性介绍

元组和列表一样，也是一种序列。
唯一的不同是，元组是相对不可变的。

>>> tl = ()   #创建空的元组
>>> v_tp = (3)
>>> only_tp = 3,
>>> type(v_tp)
<class 'int'>
>>> type(only_tp)
<class 'tuple'>    # 为元组

创建非空元素的元组是用逗号(,)，而不是用小括号

#tuple 对其他序列类型的数据转换为元组.
>>> sl = 'car'  #字符串类型
>>> li = [1,2,3]

>>> tuple(sl)
('c', 'a', 'r')
>>> tuple(li)
(1, 2, 3)

>>> tl = (1,2,3,['a','b'])
>>> tl[3][0]=0
>>> tl
(1, 2, 3, [0, 'b'])

2、使用元组的理由

占用内存空间小
元组内的值不会被意外的修改
可作为字典的键
函数的参数是以元组形式传递的
命名元组有时候可以代替类的对象