一.Python基础语法

1基本数据类型

1.1 数值

int 整数
与C、C++、Java不同，Python中整数类型只有一个int，没有短整型short、长整形long。

1.2 浮点数

float 浮点数

1.3 布尔值

bool 布尔值True or Flase
非零即为Ture，零则为False

     In [4]: type(0.3)
     Out[4]: float
     In [5]: type(True)
     Out[5]: bool
     In [6]: type(1)
     Out[6]: int

2 序列类型

2.1 列表

一个有序的队列,可变数据类型;
元素可以是任意对象;
列表内元素有序，可以使用索引;
线性的数据结构;
使用[]表示

列表的定义

list()–new empty list 定义一个空列表
list(iterable)–>new list initialized from iterable

lst1  = list()
lst2 = list(range(10))   
lst = ["2", "3", "a", [1, 2, 3]]

列表的访问
列表索引访问，也叫下标访问
正索引，从左至右，从0开始
负索引，从右至坐，从-1开始
索引不可以超界

In [23]: lst = list(range(10))

In [24]: print(lst)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [25]: lst[0]
Out[25]: 0

In [26]: lst[10]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-26-655442512158> in <module>()
----> 1 lst[10]

IndexError: list index out of range

In [27]: lst[-1]
Out[27]: 9

列表查询

index(value,[start,[stop]])
通过值value，从指定区间查找列表内的元素的是否匹配
匹配第一个就立即返回
匹配不到，抛出异常ValueError
count(value)
返回列表中匹配value的次数
时间复杂度
index和count的方法O(n)
随着列表数据规模增大而效率下降
len(list)如果返回列表的个数

列表修改

append(object)-None
列表尾部追加元素，返回None
返回None意味着没有新的列表产生，就地修改
时间复杂大O(1)
insert(index,object)-None 尽量少用
在指定的索引index处插入元素Object
返回None，不产生新列表，就地修改
时间复杂度O(1)
索引能超上下界吗？超越上界，尾部追加, 超越下界，头部追加
extend(iterable)–None
将可迭代对象的元素追加进来，返回None
就地修改
±->list
连接操作，将两个列表连起来
产生新的列表，原列表不变
本质上调用的是__add__()方法
*–list
重复操作，将本列表元素重复n次，返回新列表

列表删除元素

remove(value)——Nnoe 少做
从左至右查找第一个匹配的vlaue的值，移除
就地修改
pop([inde])–item
不指定索引，从尾部弹出
clear()–None 清空所有元素

列表其他操作

reversed()-None
将列表元素反转
就地修改
sort(key=None,reverse=False)–None
对列表元素进行排序，就地修改，默认升序
reverse为True，反转，降序
key为一个函数，指定key如何排序
in
[3,4] in [1,2,[3,4]]
for i in [1,2,3,4]

列表复制

copy()->list
浅复制，shadow copy
深拷贝
copy模块提供了deepcopy

import copy
lst0=[1,[2,3,4],5]
lst1=lst0.deepcopy()

2.2元组

tuple 元组，与列表相似，同样支持下标访问，区别它不可变

命名元组 namedtuple
namedtuple(typename,filed_names,verbose=False,rename=False)
命名元组，返回一个元组的子类
file_names可以是空格或逗号分隔字符

from collections import namedtuple
Student=namedtuple('Stu','name age') //首Student为类名
tom=Student('tom',20)

元组示例

tup1  = ()  # 空元组
tup2 = tuple() # 空元组
tup3 = tuple(range(10))  
print(tup3[0], tup3(1), tup3(-1))
tup3[0] = 27 # 错误，元组不可变

2.3 字符串

一个个字符组成的有序的序列，是字符的结合
使用单引号、双引号、三引号
不可变对象
Python3起，字符串就是Unicode类型
支持使用索引访问
有序的字符集合，字符序列
可迭代

字符串join连接
字符串分割
* split() 将字符串按照分隔符分隔成若干字符串，返回列表
* split() 从左至右分隔
* rsplit() 从右至左分隔
* splitlines([keepends])->list of strings
按照行来切分字符串
keepends指的是是否保留行分隔符
行分隔符包括\n,\r\n,\r等
* partition(sep)–(head,sep,tail) 将字符串按照分隔符分隔成2两部分，返回头、分隔符、尾三部分的元组；如果没有找到分隔符，就返回头、2个空字符的三元组
sep参数分割字符串，必须指定
* rpartition(sep)–(head,sep,tail) 从右至左
字符串大小写
upper()
lower()
swapcase() 交互大小写
字符串排版
title()–>每个标题的单词大写
cacpitalize()
center(width[,fillchar])
zfill(width)–>str
ljust(width[,fillchar])
rjust(width[,fillchar])
字符串替换
replace(old,new[count])–>str
字符串修改*
strip([chars])–>str
从两端去掉字符集chars的所有字符
rstrip([chars])–>str
lstrip([chars])–>str
字符串查找
find(sub[,start[,end]])–>int
rfind(sub[,start[,end]])–>int
index(sub[,start[,end]])–>int
rindex(sub[,start[,end]])–>int
注意: find 没有找到，返回-1; index没有找到，抛出异常valueerror
字符串判断
endswitch(suffix[,start[,end]])–>bool
startswith(prefix[,start[,end]])–>bool
isalnum()是否是字母和数字
isalpha()是否是字母
isdecimal()
isdigit()
isidentifier()
islower()
isupper()
isspace()
字符串拼接
join()
+ 拼接字符串
字符串格式化
% 2.5版本之前
format 2.5版本之后 (推荐使用)

```python
     "{0[0]},{0[1]}".format(('a','b'))
    from collections import namedtuple
    Point=namedtuple('Poinx','x y')
    p=Point(4,5)
    "{{{0.x}}},{{{0.y}}}".format(p)
    # 对齐
    "{0:<2}".format(3)  # 右对齐
    "{0:>2}”.format(3) # 左对齐
    "{0:^2}”.format(3)  # 居中
    "{0:*^20}".format(3)
  # 进制
   "{0:d}".format(3)
   "{0:x}".format(3)
   "{0:o}".format(3)
   "{0:b}".format(3)
   "{0:#d}".format(3)
   "{0:#x}".format(3)
   "{0:#o}".format(3)
   "{0:#b}".format(3)
```

Python3中引入了两个新类型

bytes 不可变的字节序列
bytearray 字节数组、可变

字符串与bytes

        字符串是字符组成的有序序列，字符可以编码
        bytes是字节组成的有序的不可变序列
        bytearray是字节组成的有序的可变序列

编码

字符串是按照不同的字符编码encode返回字节序列bytes
encode(encoding=‘utf-8’,errors=‘strict’)–bytes
字节序列按照不同的字符集解码decode返回字符串
bytes.decode(encoding=‘uft-8’,erros=‘strict’)–str
bytearray.decode(encoding=‘utf-8’,errors=‘strict’)–str
bytes() 空bytes
bytes(int) 指定字节的bytes，被0填充
bytes(iterable_of_ints)
bytes(string,encoding[,errors]) 字符串指定编码等价于string.encoding(),常用这种
bytes(bytes_or_buffer) 从一个字节序列或者buffer复制出一个新的不可变

bytes对象

使用b前缀定义
只允许基本ASCII使用字符形式b’abc9’
使用16进制表示b"\x41\x61"
bytes操作
* 和String类似，但注意输入的是bytes，输出也是bytes，需要加b前缀
“b"abcdef”.replace(b’f’,b’k’)
* 类方法bytes.fromhex(string)
string必须是2个字符的16进制形式
* hex()
返回16进制表示的字符串
‘abc’.encode().hex()
* 索引
b’abcdef’[2]返回该字节对应的数，int类型
bytearray定义
和bytes()类似
bytearray() 空bytes
bytearray(int)
bytearray(iterable_of_ints)
bytearray(string,encoding[,errors])
bytearray(bytes_or_buffer)

因为可变所以比bytes多修改类的操作
append()
insert()
extend()
pop()
remove() 找不到抛出异常
clear()
reverse()

list、tuple、字符串、bytes、bytearray都是线性的

线性结构:
可迭代
len()
通过下标访问
可以切片操作

2.4 集合

set 可变的,无序的,不重复的元素的集合

set:定义初始化

set中的元素都是不可变的,list\bytearray等可变类型不能作为set的元素.或者不可哈希的,不能作为集合的元素.

set中的元素:

set中的元素要求必须可以hash
不可哈希类型:list\bytearray
元素不可以索引
set可以迭代

set中增加元素

add(elem) 增加一个元素到set中,如果元素存在,什么都不做
update(*others) 合并其他元素到set集合中,参数others必须是可迭代的,就地修改.

set中删除元素

remove(elem) 从set中移除一个元素,元组不存在,抛出keyerror异常.
通过计算哈希值,找到elem,然后移除,而非类似列表中的遍历,效率要高
discard(elem) 从set中移除一个元素,元素不存在,什么都不做
pop()–>item //使用时,不需要参数
移除并返回随机的元素.
空集合返回KeyError异常
clear()
移除所有元素

set修改,查询

修改要么删除,要么加入新的元素,没有直接修改的操作
查询非线性结构,无法索引
遍历可迭代
成员运算符 in和not in 判断元素是否存在.效率很高

set和线性结构

线性线性结构的查询时间复杂度O(n)，随着数据规模的增大，耗时越来越长
set、dict等结构，内部使用哈希值作为key，时间复杂度可以做到O(1)，查询时间和数据规模无关。

可哈希类型

数值型 int、float、complex等
bool类型
字符串类型string、bytes
tuple
None
以上都是不可变类型，成为可哈希类型

集合运算

并集：
union(*others)：返回和多个集合合并后的新集合
| 运算符重载，等同于union
update(*others) 和多个集合合并，就地修改
|= 等同于update 中间不可以有空格
交集:
intersection(*others) 返回和多个集合的交集
等同于 &
intersection_update(*others)
获取多个集合的交集，并就地修改
&= 等同于intersection_update
差集：
difference(*others)
等同于 - 返回多个集合的差集
differnece_update(*others) 获取和多个集合的差集就地修改
-= 等同于difference_update
对称差集
集合A和B，由所有不属于A和B的交集元素组成的集合，记作(A-B) U (B-A)
symmetric_difference(other)
返回和另一个集合的对称差集
等同于^
symmetric_difference_update()
获取和另一个集合的差集，就地修改
等同于^=
issubset(other)、 <= 判断当前集合是否是另一个集合的子集
set1 < set2
判断set1是否是set2的真子集
issuperset(other) >=
判断当前集合是否是other的超集
set1 > set2
判断set1是否是set2的真超集
isdisjoint(other)
当前集合和另一个集合没有交接，没有交接返回True

2.5 字典

字典dict

key-value键值对的数据的集合
可变的、无序的、key不可重复

字典的定义初始化：

d = dict() 或者 d = {}
ditc(**kwargs) 使用name=value对初始化一个字典
dict(a=‘zhangsan’,b=‘lisi’)
dict(iterable,**kwarg)使用可迭代对象和name=value对构造字典，不过可迭代对象的元素必须是一个二元结构。
dict(((1,‘a’),(2,‘b’)))
dict(mapping,**kwarg) 使用一个字典构建另一个字典
类方法：
d = dict.fromkeys(range(5))
d = dict.fromkeys(range(5), 0)

字典元素访问
d[key]
返回key对应的值，key不存在抛出异常
get[key[,default]]
返回key对应的值，key不存在返回缺省值，没有缺省值返回None
setdefault(key[,default])
返回key对应的值，key不存在，则添加key-value。
字典增加和修改

d[key]=value
将key对应的值改为vlaue，如果key不存在，则添加
update([other])–>None
使用另一个字典的kv更新本字典
key不存在，则添加
可存在，覆盖已存在的key对应的值
就地修改
d.update(red=1)
d.update(((‘red’,2),))
d.update({‘red’:3})

字典删除
pop(key[,default])
key存在，移除它，返回它的value
key不存在，返回给定的default
未设置default，key不存在则抛出异常
popitem()
移除并返回一个任意的键值对
字典为empty，抛出keyError异常
clear()
清空字典
del语句:del 本质上是减少了一个对象的引用，del实际上删除的是名称，而不是对象
字典遍历

for ... in dict
    遍历key
        for k in d:
            print(k)
        for k in d.keys():
            print(k)
    遍历value
        for k in d:
            print(d[k])
        for k in d.keys():
            print(d.get(k))
    遍历item
        for item in d.items():
            print(item)
        for k,v in d.items():
            print(k,v)

总结：
Python3中，keys，values，items方法返回一个类似生成器的可迭代对象，不会把函数的结果复制到内存中。
Python2中，上面的方法会返回一个新的列表，占据新的内存空间，所以python2建议使用iterkeys、itervalues、iteritems版本，
返回一个迭代器，而不是一个copy。
字典的key
key的要求和set元素要求一致

defaultdict

collections.defaultdict(default_factory[,…])
第一个参数是default_factory,缺省是None。它提供了一个初始化函数，当key不存在的时候，会调用这个初始化函数，生成key对应的value。

    from collections import defaultdict
    d1 = {}
    d2 = default(list)
    for k in "abcde":
        for v in range(5):
            if k not in d1.keys():
                d1[k]=[]
            d1[key].append(v)
    print(d1)
    for k in 'mnopq':
        for v in range(3):
            d2[k].append(v)
    print(d2)

OrederedDict 解决3.5版本及之前版本字典key无序的问题

collections.OrderedDict(itmes)
key并不是按照加入的顺序排列，可以使用OrderedtDict记录顺序

    from collections import OrderedDict
    import random
    d = {'banana':3, 'apple':4, 'pear':1, 'Orange':2}
    print(d)
    keys=list(d.keys())
    random.shuffle(keys)
    print(keys)
    od = OrderedDict()
    for key in keys:
        od[key] = d[key]
    print(od)
    print(od.keys())

3.6版本字典dict中记录了字典中元素的加入顺序

3. 运算符

3.1 算数运算符

算数运算符如下

运算符	描述	实例
+	加	10 + 30
-	减	5 - 3
*	乘	30 * 20
/	除	10 / 20
//	取整除	返回除法的整数部分（商），如 7 // 2 输出结果 3
%	取余数	返回除法的余数 7 % 2 = 1
**	幂	又称次方、乘方，2 ** 3 = 8

算数运算符的优先级

和数学中的运算符的优先级一致，在 Python 中进行数学计算时，同样也是：
* 先乘除后加减
* 同级运算符是 从左至右 计算
* 可以使用 () 调整计算的优先级

以下表格的算数优先级由高到最低顺序排列

运算符	描述
**	幂 (最高优先级)
* / % //	乘、除、取余数、取整除
+ -	加法、减法

3.2.位运算符

运算符	描述
&	位与
\|	位或
~	取反
^	异或
<<	左边移位
>>	右边移位

2.3 比较运算符

运算符	描述
>	大于
>=	大于等于
<	小于
<=	小于等于
==	等于
!= 、<>	不等于

3.4 赋值运算符

运算符	描述
+=	a+=1 等价于 a=a+1
-=	类似
*=	…
**=	…
/=	…
%=	…

3.5逻辑运算符

运算符	描述
and	逻辑"与"，两边为真返回布尔值’True’，否则返回False
or	逻辑"或"，两边为假返回布尔值’Flase’，否则返回True
not	逻辑"非"

3.6 成员运算符

运算符	描述
in	如果在指定的序列中返回True，否则返回Flase
not in	若不在指定的序列中返回True，否则返回False

4. 变量

4.1 变量定义

在 Python 中，每个变量 在使用前都必须赋值，变量 赋值以后 该变量 才会被创建

变量名 = 值

示例

# 定义 class_num 的变量用来保存班级序号
In [8]: class_num = '01'
In [9]: print(class_num)
01

4.2 变量的类型

在 Python 中定义变量是 不需要指定类型（在其他很多高级语言中都需要）
数据类型可以分为 数值型 和 非数值型
数字型
- 整型 (int)
- 浮点型（float）
- 布尔型（bool）
  - 真 True ---- 非零即真
  - 假 False ----0
- 复数型 (complex)
  - 主要用于科学计算
非数值类型
- 字符串
- 列表
- 元组
- 字典
使用 type() 函数可以查看一个变量的类型

4.3 不同类型变量之间的计算

1) 数值类型变量之间可以直接计算

在 Python 中，两个数值类型变量是可以直接进行算数运算的
如果变量是 bool 型，在计算时
- True 对应的数字是 1
- False 对应的数字是 0

2) 字符串变量之间使用 `+` 号，则是进行字符串的拼接

In [10]: str1 = "My name is"

In [11]: str2 = "张三"

In [12]: str1 + str2
Out[12]: 'My name is张三'

3) 数值类型变量和字符串之间不能进行其他计算

In [16]: str1 = "She is"

In [17]: age = 18

In [18]: str1 + age
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-18-0a392e70e75a> in <module>()
----> 1 str1 + age

TypeError: can only concatenate str (not "int") to str

4.4 变量的输入 input

在 Python 中，如果要获取用户在键盘上的输入信息，需要使用到 input 函数

函数: 封装好的代码块，可以进行复用(别人或者自己写的代码)，可以直接使用，而 不用关心内部的细节

函数	说明
print(x)	将 x 输出到控制台
type(x)	查看 x 的变量类型
input	获取键盘输入

示例:

In [19]: info = input("输入信息")
输入信息12345

In [20]: info
Out[20]: '12345'

变量类型转换

函数	说明
int(x)	将 x 转换为一个整数
float(x)	将 x 转换到一个浮点数

5 程序控制

高级语言中，程序控制无非是顺序、分支、循环

5.1顺序

按照先后顺序一条条执行
示例代码

""" 
先定义变量 a、b，再定义变量c，最后打印c的值
"""
a = 1
b = 2
c = a + b
print(c)

5.2 分支

Python的分支语句就是if，满足条件则执行，不满足则转到下一个分支条件

a = 1
b = 2
max_num = None
if a > b:
    print(a)
elif a<b:
    print(b)
else:
    print("a = b")

5.2 循环语句

whlie循环

a = 1
sum = 0
max_num = 9
while a < max_num:
       sum + = a
       a += 1
print(sum)

for 循环
常用语遍历
示例代码打印九九乘法表

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

来源：CSDN

作者：leafgood

链接：https://blog.csdn.net/qq_38756978/article/details/103751940

标签

python for循环

运算符优先级

python字符串连接

python字符串操作

目录

1基本数据类型

1.1 数值

1.2 浮点数

1.3 布尔值

2 序列类型

2.1 列表

列表的定义

列表查询

列表修改

列表删除元素

列表其他操作

列表复制

2.2元组

元组示例

2.3 字符串

Python3中引入了两个新类型

字符串与bytes

编码

bytes对象

list、tuple、字符串、bytes、bytearray都是线性的

2.4 集合

set:定义初始化

set中的元素:

set中增加元素

set中删除元素

set修改,查询

set和线性结构

可哈希类型

集合运算

2.5 字典

defaultdict

OrederedDict 解决3.5版本及之前版本字典key无序的问题

3. 运算符

3.1 算数运算符

3.2.位运算符

2.3 比较运算符

3.4 赋值运算符

3.5逻辑运算符

3.6 成员运算符

4. 变量

4.1 变量定义

示例

4.2 变量的类型

4.3 不同类型变量之间的计算

1) 数值类型变量之间可以直接计算

2) 字符串变量 之间使用 + 号，则是进行字符串的拼接

3) 数值类型变量 和 字符串 之间 不能进行其他计算

4.4 变量的输入 input

变量类型转换

5 程序控制

5.1顺序

5.2 分支

5.2 循环语句

2) 字符串变量之间使用 `+` 号，则是进行字符串的拼接

3) 数值类型变量和字符串之间不能进行其他计算