Python记1（输入/出，字符，数据类型，运算符，语句，with

1、杂：

• 可能有用的网站
   #Python查询 https://docs.python.org/zh-cn/3/tutorial/interpreter.html

• 2种模式：交互模式和脚步模式

• 变量使用前无需声明

• 缩进表示代码块（C++用{}）

• 大小写不同

• 标识符必须以下划线或字母开头，python3支持非英文字符

• 没有命名常量，常量无名字

• 一切皆对象：type->int->1

print(type(1))      # 输出：
print(type(int))    # 输出：
print(type(type))   # 输出： type是一个类，同时是一个对象！

• object与type：构成环路

print(type.__base__)   # 输出：，type是object的子类
print(type(object))    # 输出：，object是type的实例（对象）
print(object.__base__) # 输出：None，object不继承任何对象

2、输入、输出：

string=input("提示信息")#返回的是字符串类型！
>>>num=int(input("请输入整数："))
请输入整数：100
print(输出内容，end)，end默认是回车，如：      （python2不需要加括号()）
print("Hello,Sir"）#输出Hello,Sir
print(1+2)#输出3
print("输入整数是：%d" %(num))
print("Hi, %s,I'm %s" %("Mike","John"))
print("1",end="-")   #则输出1后不回车，而是输出-，若end=""表示输出1后不操作

3、特殊字符，转义字符：

\r  回车
\n 换行
\t  横向制表符
\v  纵向制表符
\f  换页
\a  响铃
\b  退格（Backspace）
\(行尾）续行符
\\  反斜杠符号
\’  单引号
\” 双引号
\000   空
\oyyy  八进制数yyy代表的字符
\xyy   十进制数yy代表的字符
％c 字符及其 ASCII码
％s 字符串
％d 整数
％u 无符号整型
％o 无符号八进制数
％x 无符号十六进制数
％X 无符号十六进制数（大写）
％f 浮点数字，可指定小数点后的精度，如%.5f表示保留5位小数
％e 用科学计数法格式化浮点数
％p 用十六进制数格式化变量的地址

失效转义字符：

 >>>print("C: \MyProgram\rencent\num\test\ score" )
ecentrogram
 um         est\score
 >>>print(r 'C: \MyProgram\ rencentnum\ test\score" )
C: \My Program\ rencent\num\test\score
 >>>print (R'C: \MyProgram\rencent\num\test\score")    #r与R相同？
C:\MyProgram\ rencent\num\test\score
4、format格式化输出
#不带编号
>>>print（＂今天是{}年{}月{}日 ＂ .format(2019,5,18))                          
今天是2019年5月18日

#带数字编号
>>>print(‘她叫{0}，今年{1}岁，她的朋友lisa，今年也{1}岁了’.format（’Lucy’,10))    
她叫Lucy，今年10岁，她的朋友lisa，今年也10岁了

#带关键字
 >>>print（‘她叫{name}，今年 {age}岁。’.format （age=10,name= ‘Lucy’）          
她叫Lucy，今年10岁。

#用{}转义大括号
>>>print ("{} 对应的位置是 {{0}}".format("runoob"))
runoob 对应的位置是 {0}

#｛：填充字符 对齐方式 数据宽度 数据类型｝
>>>print('第一个数字是{: ! > 8 .3f}'.format(12.98))  #用"!"填充，右对齐，数据宽度为8位，保留3位有效小数的浮点数表示
>>第一个数字是!!12.980

填充：默认空格填充
对齐：默认右对齐<  左对齐<  中间对齐^
数据类型：f浮点数、b二进制、o八进制、d十进制、x十六进制

5、数据类型

 主要的有6种：数字、字符串、列表、元组、字典、集合
 还有动态类型等概念（如鸭子类型）
 其中集合set、列表list、字典dict都是用cpython实现，运行效率较高

 数字：整型int，可以任意大
    浮点数float
    布尔值：1真、0假
    复数：1+2i

 字符串string：成对的单引号或双引号、三引号指定一个多行字符、也可用三引号做多行注释
 字符串前添加一个‘r’：让反斜杠“\”转义字符失效：
 “\”可作为续行符

print(r'C:\some\name')     #\n失效，输出：C:\some\name
print('str'+'ing ','my'*3) #+ 、* 运算符，输出：string mymymy
print('str\
        ing')              #输出：string

5.1数据类型转化

int(x,base)转换为整型    int(“123”)     #向0取整int(3.5)=3、int(-3.5)=3
float()    转换为浮点型  float(“123”)
bool()     转换为布尔型  bool(1)
str()      转换为字符串  str(123)
chr()      将整数转换为对应的 ASCII字符
ord()     将一个字符转换为对应的 ASCII码
complex()  转换为复数型  complex(1)

6、运算符

• 重载运算符参见另外一篇笔记：https://blog.csdn.net/qq_42888201/article/details/123101353
• 算术运算符

+   加   1+2=3
-   减   3-1=2
*   乘   2*3=6
/   除   7/2=3.5（精确除法）
％  求模  7％2=1（取余数，余数符号和除数一致，7%-2=-1)
**  幂运算2**3=8
//  整除  7//2.0=3.0（比商小的最大整数，-7//2=-4）

• 赋值运算符

=     #连续赋值a=b=c=1，多元赋值(x,y,z)=(1,2,'Python')(例如x,y=y,x，交换x和y)
+=    #x+=2就是x=x+2
类似有-=  *=  /=  %=(x%=2就是x=x%2)  **=  //(x//2就是x=x//2)

• 字符串运算符：
  +（字符串连接）

>>>py="Python"
>>>v2="2.0"
>>>v3="3.0"
>>>print(py+v2, py+v3)
Python2.0 Python3.0
* （重复输出多次）
>>>print("重要的话说三遍！”*3)
重要的话说三遍！重要的话说三遍！重要的话说三遍！
成员运算符：in、not in
>>>str="Hello!"
>>>'H' in str
True

• 其他：

不等于   !=   <>
位运算符： &与 丨或  ～非  ^异或  <<左移  >>右移

• 优先级：自上而下，自左而右（如：*高于~±高于/%//高于±）

运算符	描述	运算符	描述
**	指数 (最高优先级)	<= < > >=	比较运算符
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)	<> == !=	比较运算符
* / % //	乘，除，取模和取整除	= %= /= //= -= += *= **=	赋值运算符
+ -	加法减法	is is not	身份运算符
>> <<	右移，左移运算符	in not in	成员运算符
&	位 ‘AND’	not or and
^	位运算符

7、语句

7.1、条件分支：if…（elif…elif…）else…

if x<y:
    print(" is less than.")
elif x>y:
    print(" is greater than.")
else: 
    print(" is equal to.")
print("continue....")

7.2、条件表达式:

表达式1 if判断条件 else 表达式2

print(a if a>b else b)  #打印a、b最大值

7.3、循环while、for：

• 循环1：

while 循环条件:
   循环体

i=1   #计算1到100之和
sum=0
while i<101:
    sum+=i
    i+=1    

• 循环2：

for 标识符 in 可迭代对象：
  循环体

for c in "Python":
    print(c,end="")     

print("")       # 会自动回车
for i,val in enumerate("abc"):
    print("序号：{}\t值：{}".format(i,val))


[print(c,end="") for c in "Python"]

# [a=c for c in "Python"]	但是不能赋值，这里报错
# 打印：
Python
序号：0	值：a
序号：1	值：b
序号：2	值：c
Python

7.4、上下文管理类型 with

 with语句可以简化try-except-fibally语句（但不完全相同）
 with：对于需要进行访问的任务，无论是否发生异常，都会执行必要的清理工作（文件关闭、线程中锁的自动获取和释放）

with 上下文管理器表达式 [as 变量]:  #表达式：上下文管理器对象或函数（返回值是上下文管理器对象）
    语句块

with open("mypython.txt") as f:    #as f 可选
    print(f.read())   #with完成时会自动关闭文件    

实现上下文管理器：

在类定义时，实现__enter__()和__exit__()即可
在with语句块前先调用__enter__()，with后调用__exit__()，释放资源通常在exit中

eg.模拟实现一个文件类：

class File ()
	def __init__(self, filename, mode):
		self.filename=filename
      	self.mode=mode
    def __enter__(self):
		print("执行__enter__()方法")
		self.f=open(self.filenam, self.mode)
		return self.f
	
	def __exit__(self, *args):
		print("执行__exit__()方法")
		self.f.close()

with File('mypython.txt','r') as f:
	print(f.read())   #f内容：xxx
#正常输出结果：
执行__enter__()方法
xxx
执行__exit__()方法

7.5、is、==

is与==不同，is相当于判断对象的id()是否相等，而==是判断两个函数返回的值是否相等

8、序列数据结构：字符串str、列表list[]、元组tuple()、bytes/bytearray/memoryview(二进制序列)

8.1、元组（tuple）：

一经定义不能改变，可以是不同的数据类型（列表也可以不同类型）

t1=(1)    #t1是整数
t2=(1,)   #t2是元组！！type((1,)) = tuple

8.2、索引：

正向和逆向

>>>str_py="Python"
>>>print(str_py[-1])    #逆向索引
n

8.3、切片：

#字符串切片

>>>str_py="Python"
>>>print(str_py[1:5])
'ytho'

>>>print(str_py[1:])   #str_py[:5]类似，不填写表示到尽头
'ython'

#列表切片
>>>list1=[1,2,3]
>>>list1[1:]
[2,3]
>>>print(list1)   #打印整个列表
[1,2,3]
>>>print(list1[0])    #打印列表某个元素
1

8.4、len(序列名称)

序列名称可以是字符串、列表、元组

ndarray 转 list：ndarray对象.tolist()

>>>str="Python"
>>>len(str)
6   #len("Python")也是6

8.5、列表插入：append(元素) insert(索引号,元素)

>>>list_1=[1,2,3]
>>>list_1.append(4)		# 没有返回值，但是+有返回值
>>>list_1
[1,2,3,4]
>>>list_1.insert(1,5)
[1,5,2,3,4]

8.6、列表合并：extend(列表) +

>>>list_1=[1,2,3]
>>>list_2=[4,5]
>>>list_1.extend(list_2)    #等价于list_1=list_1+list_2
>>>list_1
[1,2,3,4,5]

8.7、列表删除部分：del、pop、remove

>>>list_1=[1,2,3]
>>>del list_1[1]
>>>list_1
[1,3,4]

• 第一种：del命令。删除元素后续不再使用。
  格式：del name[3]

• 第二种：.pop（）。 保存删除的元素备用。
  格式：popped_names = names.pop(3)
  语法：list.pop([index=-1])
  index：可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值

• 第三种：.remove()。 不知道位置，根据element的值剔除元素。
  格式： names.remove(‘value’)

8.8、列表排序：顺序 sort(列表) 倒序 reverse(列表)

>>>list_1=[2,3,1,4]
>>>list_1.sort()
>>>list_1
[1,2,3,4]       #用list_1.reverse()则输出[4,3,2,1]

8.9、字符串分割：split()、rsplit()、filter()

# str.split(" ")    用空格分割，划分多个空格请不要输入参数
print("a b cc d".split(" "))        # ['a', 'b', 'cc', 'd']
print("a b cc d".split(" ", 2))     # 仅划分前2个空格：['a', 'b', 'cc d']
print("a b   cc  d".split(" "))     # 有""：['a', 'b', '', '', 'cc', '', 'd']
print("a b   cc  d".split())        # 无""：['a', 'b', 'cc', 'd']

# rsplit就是从最后开始分割
print("a b   cc  d".rsplit("  ", 1)) 	# ['a b   cc', 'd']

# 用filter(判断函数, 可迭代对象)
filter_obj = filter(None, "a b   cc  d".split(" ")) 
filter_obj = filter(lambda x:x!="", "a b   cc  d".split(" ")) # 或者这个一样
print(list(filter_obj))             # ['a', 'b', 'cc', 'd']

9、字典dict 键/值对（key/vale）

创建

>>>dic_score={"语文":80,"数学":85,"英语":70}
>>>dic_student1={"name":"Mary","age":26}
>>>dic_student2={"name":{"first":Mary,"last":"Smith"},"age":26}

打印

>>>print(dic_score)          #打印字典
{"语文":80,"数学":85,"英语":90}
>>>print(dic_score["语文"])   #打印元素
80

遍历：

>>>for key_score in dic_score.keys():   #遍历键   .key()
       print(key_score,end=" ")
70 80 85    #字典中的元素是无序的

>>>dic_student={‘name':’张明',’sex':'男','age':18,'score':98}
>>>for value in dic_ student.values():   #遍历所有值 .value()
    print(value, end=" “)
18 张明 98 男
>>>for item in dic_student.items():      #遍历所有的键值对  .items()
    print(item,end=" ")
('age',18) ('name','张明') ('score':98) ('sex','男')

查找：dict.get(key, default=None)
key – 字典中要查找的键。
default – 如果指定键的值不存在时，返回该默认值。
其它：

>>>len(dic_score)            #len
3
>>>"数学" in dic_score       #in
Ture
>>>dic_score['体育']=98      #添加元素  此时，dic_score={"语文":80,"数学":85,"体育"=98,"英语":90}
>>>dic_score['体育']=76      #修改元素  此时，dic_score={"语文":80,"数学":85,"英语":90,"体育"=76}
>>>dic_score.pop('体育')     #删除元素  此时，dic_score={"语文":80,"数学":85,"英语":90}
>>>doc_score2=['体育':100]
>>>dic_score.update (dic_score2)   #合并字典  此时，dic_score={"语文":80,"数学":85,"体育":100,"英语":90}
>>>dic_student2.clear()    #清空字典所有元素   此时，dic_student2={}

传递参数：**param：两个星号**，表示将多个参数放入）

10、集合 set、frozenset(不可修改）

    由一组无序的元素组成，无序所以不能用下标访问
    集合set和字典dict效率在Python中较高

创建、打印：

>>>set1=(1,2,3,2,3)   #创建时自动去除重复元素，实际上set1={1,2,3}
>>>print(set1)
{1,2,3}  
>>>len(set1)
3
>>>set2=set("Python")  #创建可变集合，可增、删、改
>>>print(set2)
{'n','P','o','t','h','y'}
>>>set3=frozenset("Hello")  #创建不可变集合

12、鸭子类型

望文生义：

当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。（也就是多态与泛型）

• 鸭子类型（英语：duck typing）是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由"当前方法和属性的集合"决定。

class A(object):
    def say(self):
        print("A 的say函数")

class B(object):
    def say(self):
        print("B 的say函数")

objList = [A, B]
for i in objList:
    i().say()       # i()实例化对象，不同的类，函数名相同，可用统一的变量i表示（多态）

# 输出：
A 的say函数
B 的say函数

​