Python学习基础

1.数据类型和变量

整数（负整数）int----无大小限制

浮点数 float ：------无大小限制。科学计数法表示，把10用e表示。eg：1.23x109就是1.23e9

字符串 str ：" ",' '配套使用。"""三引号可放在最外面懒人用法（可表示多行内容。多个引号可用）三引号外面加r效果：转义字符无效，多行内容仍然有效。

"\"转义字符。eg：

'I\'m \"OK\"!'

输出I'm "OK"!

转义字符：\n-----换行 \t -----制表符 \ ------转义 \\------\        r'  '------表'  '内部的字符串默认不转义

布尔值：True/False。and（与：同时满足T） ,or（或：有一个满足T）,not（非） 运算

空值：None

变量：不能数字开头，不用初始化直接赋值。导致一个变量可以反复被不同类型赋值。因此Python是动态语言。type（）可以查看数据类型。

常量：通常用全部大写的变量名表示（约定俗成，不硬性规定）。eg：PI = 3.14159

除法：/--------默认精确，计算结果为浮点数。        //-------称为地板除，结果为整数（取整数部分）。

2.字符串和编码

2.1编码

ASCII编码是一个字节。

Unicode字符集：把所有语言都统一到一套编码里。（常用：UCS-16）两个字节表示一个字符

UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节。节省空间。

在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8再传输到浏览器：

2.2 Python字符串

以Unicode编码的，也就是说，Python的字符串支持多语言

单个字符编码：1.ord（）：获取字符整数表示（编码）。chr（）把编码转换为对应的字符。

2，也可以用十六进制直接输出str形式。

对bytes类型的数据用带b前缀的单引号或双引号表示：eg：x = b'ABC'

（Unicode）str通过encode()方法编码为bytes:

纯英文（str）	ASCII编码为bytes
含有中文（str）	UTF-8编码为bytes

 bytes通过decode（）方法编码为str。eg：

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'

 bytes中有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节： b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')

len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数。

2.3 格式化输出

2.3.1占位符%使用

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

补充：%%--------%

2.3.2 字符串的format（）方法

会用传入的参数依次替换字符串内的占位符{0}、{1}……，

>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
'Hello, 小明, 成绩提升了 17.1%'

 2.3.3 f-string

字符串如果包含{xxx}，就会以对应的变量替换：

>>> r = 2.5
>>> s = 3.14 * r ** 2
>>> print(f'The area of a circle with radius {r} is {s:.2f}')
The area of a circle with radius 2.5 is 19.62

f-string的填充：默认空格填充。填充分为左填充、右填充、居中填充。左填充表示在字符串左侧填充，右填充表示在字符串右侧填充，居中填充表示在字符串左右两侧对称填充。>表示左填充，<表示右填充.^表示居中填充。eg：用空格或"_"填充：

 f-string宽度与精度：相关格式描述符：保留小数点位数

>>>a=123.456
#只指定width
>>> f"{a:10}"
'123.456'
#只指定0width
>>> f"{a:010}"
'000123.456'
#使用width.precision
#精确小数点后一位
>>> f"{a:8.1f}"
’123.5'
#精确小数点后两位
>>> f"{a:8.2f}"
'123.46'
>>> f"{a:.2f}"
'123.46'
#在width后面，直接加f，表示补足小数点后的位数至默认精度6
>>> f"{a:2f}"
'123.456000'

 f-string时间：

#a变量中存放一个时间
>>> f"{a:%Y-%m-%d}"
'2020-02-01'

 九九乘法表：

1,%s方式

for i in range(1,10):
    for j in range(1,i+1):
        print("%s*%s=%s" % (j,i,j*i),end=" ")
    print("\n")

2，format方式

for i in range(1,10):
    for j in range(1,i+1):
        print("{0}*{1}={2}".format(j,i,j*i),end="")
    print("\n")

3,f-string方式：

for i in range(1,10):
    for j in range(1,i+1):
        print(f"{j}*{i}={j*i},end=" ")
    print("\n")

3 list和tuple

3.1 list

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。list里面的元素的数据类型也可以不同。list元素也可以是另一个list。

初始化元素：x = ['Michael', 'Bob', 'Tracy']

索引访问元素：用索引来访问list中每一个位置的元素，索引是从0开始的，可以用-1做索引，直接获取最后一个元素，-2是倒数第2个。eg:x[0],x[1]

追加元素：1，追加元素到末尾：x.appen("某元素") 2，插入指定位置：x.insert(1,"Jack")

删除元素：1，删除末尾元素：x.pop() 2,删除指定位置的元素：x.pop(0)

替换元素：x[1]='Sarah'

嵌套的list：

>>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']

要拿到'php'可以写p[1]或者s[2][1]，因此s可以看成是一个二维数组，类似的还有三维、四维……数组，不过很少用到。

3.2 tuple

tuple和list非常类似，但是tuple一旦初始化就不能修改。没有append()，insert()这样的方法，可以使用索引与list相同。

初始化元素：t = ['Michael', 'Bob', 'Tracy']

如果定义一个元素的tuple，必须加一个逗号“,”来消除歧义，避免定义成1这个数

>>> t = (1,)
>>> t
(1,)

 嵌套元素：tuple中嵌套的是list元素可改。表面看是“可变的”tuple。eg：

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

4.条件判断

根据Python的缩进规则，如果if语句判断是True，就执行缩进的语句，否则，什么也不做。

也可以给if添加一个else语句，意思是，如果if判断是False，不要执行if的内容，去把else执行了。注意不要少写了冒号。elif是else if的缩写做更细致的判断：

age = 3
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')

 5，用户输入

input（）读取用户的输入，获取的默认元素类型是str。若为数字参与运算比较时，需要进行类型转换：

字符型	str（）
浮点型	float（）
整数型	int（）

6，循环

6.1 for...in

for x in ...循环就是把每个元素带入变量x，然后执行缩进快的语句。依次吧list或tuple中的每个元素迭代出来，eg：

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

#结果：
#Michael
#Bob
#Tracy

 补充：rang()函数,可以生成一个整数序列。再通过list()函数可以转换为list。eg：

>>> list(range(5))
[0, 1, 2, 3, 4]

6.2 while

比如计算100以内所有奇数之和：

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

补充：break：作用是提前结束循环。continue：作用是跳过当前的这次循环，直接开始下一次循环。

如果代码写得有问题，会让程序陷入“死循环”，也就是永远循环下去。这时可以用Ctrl+C退出程序，或者强制结束Python进程。

7，dict和set

7.1 dict

全称dictionary------map，使用键-值（key-value）存储，具有极快的查找速度。dict的key必须是不可变对象。

初始化：1，

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

2，通过key放入：（一个key只能对应一个value，多次修改会把原来的value值覆盖）

>>> d['Adam'] = 67
>>> d['Adam']
67

 判断key是否存在：

通过in判断key是否存在：	'某元素' in 某字典
通过dict提供get()方法：返回（None/value）	1，某字典.get("某元素") 2，某字典.get("某元素"，"对应value值")

删除：某字典.pop(key)

注意：dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

1. 查找和插入的速度极快，不会随着key的增加而变慢；
2. 需要占用大量的内存，内存浪费多。

而list相反：

1. 查找和插入的时间随着元素的增加而增加；
2. 占用空间小，浪费内存很少。

所以，dict是用空间来换取时间的一种方法。

7.2 set（不变对象）

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key（自动被过滤）。set可以看成数学意义上的无序和无重复元素的集合

创建一个set，需要提供一个list作为输入集合：

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

 添加：add（key）：

>>> s.add(4)
>>> s
{1, 2, 3, 4}

 删除：remove（key）：

>>> s.remove(4)
>>> s
{1, 2, 3}

 交集（&），并集（|）：

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

7.3 不可变对象 

 str是不变对象（replace（）方法是新创建一个对象而不是真正意义上的替代，所以原先变量仍然没变），而list是可变对象（内部变化）。

tuple虽然是不变对象，但是内部可放入list，造成表面上的“可变”。