python(一)

定义

python是一门动态解释型的强类型定义语言

静态语言：编译期间做类型检查，需要事先声明变量类型
动态语言：程序运行期间做类型检查，声明变量不需要指定类型
强类型语言：不同类型之间的操作，需要强制类型转换为同一类型。
弱类型：不同类型之间可以操作，自动隐式转换，如js等
编译型语言：将程序一次性编译成二进制文件；开发效率低，不能跨平台，执行速度快，如c / c++等
解释性语言：当程序执行时，边执行边解释；开发效率高，跨平台，执行速度比编译型慢，如js / python / php等

变量

由字母，数字，下划线组成；
不能数字开头
不能是关键字
不建议中文（支持中文命名）
见名知义

常量

不能修改的量
python没有真正的常量
通常大写表示这个量是一个常量

标识符

字母/数字/下划线组成
只能字母/下划线开头
非关键字
大小写敏感（a != A）

注释

单行注释  # 此处有注释
多行注释  '''
  				此处有多行注释
  		  '''
注释快捷键视编辑器而定,一般为Ctrl + /

数据类型

整数int:不带小数点的数字,包括正负整数和0   
	    2.x版本中还有long类型,3.x版本就只有int
浮点数float:带小数点的数;float参与运算时,结果会存在误差
bool型:只有True和False ,注意大写;真或者假
复数型:3+5j,和数学的复数一致，就是i换成了j
字符串String:引号包起来的都是字符串，无论其中的内容是数字，字母等
函数type():确定函数类型

小数据池:python会将一定规则的整数/字符串驻留池中,创建一份,当你将这些整数/字符串赋值给变量时,并不会重新创建对象, 而是使用在字符串驻留池中创建好的对象。
适用对象: int（float）,str,bool 
对于低版本的python,小数据池有范围
如int ,范围在-5~256之间的都是指向同一个对象

a = 'a@'  
b = 'a@'  
print(id(a) == id(b))#True 低版本中有特殊字符时,id值不一致

num1 = 250
num2 = 250
num3 = 350
print(id(num1),id(num2),id(num3))
#num1 和 num2指向同一个地址
#num3 是另一个地址

高版本（python3.7）没有范围限制

python没有限制长整数的大小
但是机器的内存有限,整数溢出后会自动转为长整数
python3中没有long类型,只有int

复数：

复数 : 实数 + 虚数
实数 : 有理数(整数,分数【有/无限循环小数】),无理数(无限不循环小数【如：π】)
虚数 = 实部+ 虚部j   例: 5 + 2j   实部与虚部为实数,且虚部不为0
虚数的来源 :  j的平方等于 -1(一个数的平方为负数,这个数就是虚数)
复数无法比较大小，可以比较模
x = a + b j
模 : a 平方 + b 平方 再开方

复数的特点：

1.复数的表示语言 real + image j 
2.实部和虚部都是浮点数
3.j不区分大小写
4.复数的conjugate方法可以返回该复数的共轭复数
3 + 4 j 和 3 - 4 j是共轭复数

complexs = 4 + 5j
print(complexs.real) # 4.0  获取实部
print(complexs.imag)	# 5.0	获取虚部
print(abs(complexs ))	# 6.4031.... 获取模
print(complex(3,4)) #(3+4j) 获取一个复数,以3作为实部,4作为虚部

bool类型：

只有True和False,大写
其他类型有False等价
'' 空字符		False
0	数值0		False
[] 空列表		False
() 空元组		False
{} 空字典		False
set{} 空集合		False
等等

字符串：引号包含的字符

单引号 : '悟空'			#单引号可以输出双引号（不能输出与版本有关）
双引号: "  八  'j'   戒  "  #双引号中可以输出单引号
三引号： '''  #可以识别换行
				这是换行
		'''

类型判断：
type(对象)

	num = 123
    lis = [2,3]
    dic = {'name' : 23}
    print(type(num))#<class 'int'>
    print(type(num) == type(1))#True
    print(type(lis) == type([]))#True
    print(type(dic) == type({}))#True

类型转换

类型名(变量)
int(a) 将变量a转为int类型
str(b) 将变量b转为str类型

num = 1
print(str(num))
float(num)

算术运算

+		加
- 		减
*		乘
/		除  得到一个浮点数,float

print(6/3) #2.0 整数相除，结果类型为浮点数
 #python2.x版本中 除法只得到整数部分，得出的结果与//一致，
 #python2.x版本要想得出小数，需要将其中一个数改为浮点数

//  返回除法运算后商的整数部分,int类型

print(7//3) #2

**		幂运算 

print(2**3) # 8

% 取余数

print(9%2)#1

== 判断对象内容是否相等

	 lists = [1,2]#定义一个列表
    lists2 = [1,2]#定义另一个内容相同的列表
    print(lists == lists2)#True 比较内容
    print(id(lists))#38942600  获取内存地址
    print(id(lists2))#38683016	获取内存地址

！= 不等于

print(1 != 2)#True

>  >=  大于/大于等于
<  <=	小于/小于等于

+= 加等
-= 减等
*= 乘等
/=	除等
%=	取余等
**= 幂等
//= 

num1 = 3
num2 = 2
num1 += num2
print(num1)#5
num1 += num2
print(num1)#7
num1 -= num2 # 7 - 2
print(num1)#5

~ 取反，对一个数值(补码)取反

print(~12) #-13

一个数在计算机中的二进制表示形式,  叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号, 正数为0, 负数为1.
比如，十进制中的数 +3 ，计算机字长为8位，转换成二进制就是00000011。如果是 -3 ，就是 10000011 

那么，这里的 00000011 和 10000011 就是机器数。
原码, 反码, 补码是机器存储一个具体数字的编码方式
原码：符号位加上真值的绝对值
反码：
	  正数的反码是其本身
	  负数的反码是在其原码的基础上, 符号位不变，其余各个位取反
补码：
	正数的补码就是其本身
	负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)

#~12 的本质就是12 的补码取反
#原码:0000 1100
#反码：0000 1100
#补码：0000 1100
#取反：
#     1111 0011得到的这个是补码
#将取反的转为原码,补码-1得到反码
#反码： 1111 0010  反码取反得到原码,符号位不变
#原码	1000 1101 符号位不变，其余位取反
# 1000 1101 = -13

#减法的本质是用加法实现减法
'''
例 5 - 1
底层用补码相加实现减法
5的原码0000 0101
反码 0000 0101
补码 0000 0101
-1的原码 1000 0001
反码	1111 1110
补码    1111 1111
5 和 -1的补码相加
	 5的补码 0000 0101
+
	-1的补码 1111 1111	
=	1 0000 0100 溢出位舍弃，结果为
0000 0100 将之转为原码
0000 0100 将二进制转为十进制
4

'''

逻辑运算

and

if(1 and 1):#	非0数值等价于True  ; and两边都为True,执行if中代码块
        print('hhh') #hhh

a = 3 and 4  # 两边都为true,a的值为最后的真值4
print(a) # 4 

a = 43 >= 1 and 'A' < 'b' and 1 #'A'的ASCII码为65，'b'ASCII码为98
print(a)#1

or

if(1 or 0):#or两边有一边为True，整体为True，执行if中代码块
        print('hhh') #hhh
flag1 = 3>2   #True
flag2 = 2<1   #False
flag3 = flag1 and flag2   #False
flag4 = flag1 or flag2    #True

num = 3 or 2 # 非bool型的数据,全为真的时,num的值为or前面的数据的值
print(num) # 3
num2 = 0 or 2	# 非bool型的数据,一真一假时,num的值为真值
print(num2) # 2
num3 = 3 or 0
print(num3) # 3

not

if not 0:#not 将bool类型的结果反转，真变假，假变真
        print('这是对的') 

a = 3 > 2 < 2
print(a) #False
# 3 > 2 < 2 拆开看  3 > 2 and  2 < 2 等价为 True and False ==> Fasle

输入输出函数：

input ()   获取键盘输入的函数,默认是str类型
print（） 输出函数

'''
输入一个年份，判断是否是一个闰年。是，输出True；否，输出False
'''
year=int(input('请输入年份：'))#将str转为int类型，便于运算； int(str)
leap=(year%4==0)and(year%100!=0)or(year%400==0)
print(leap)

#源码：print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
f = open("123.txt", "w")
print("123456789", file = f)

f = open("123.txt", "w")
print("123456789",file = f, flush = True)
'''
sep=' ' 多个元素输出时的间隔符,默认为空格间隔
end='\n' 自动在输出后拼接一个换行符
flush参数主要是刷新, 默认flush = False,不刷新,用于页面会实时显示,例如在线聊天等
file=sys.stdout 和文件的读写相关
print到f中的内容先存到内存中,当文件对象关闭时才把内容输出到 123.txt 中;
而当flush = True时它会立即把内容刷新存到 123.txt 中。

'''

字符串

字符串（str）


一串由引号包裹的字符
不可变数据类型
有长度
下标从o开始（从左至右）
下标从-1开始（从右至左）
根据下标获取的是单个字符串

	#字符串
    s = 'abcdefghjkiuytyt'
   
    #获取单个字符
    s1 = s[2] #获取下标为2的字符
    print(s1)	#c
  
    #截取多个字符
    s2 = s[0:3] #截取下标0至下标3的元素（不包括下标3的元素）
    print(s2)	#abc
	
	 #间隔截取多个字符
    s3 = s[0:7:2]	##截取下标0至下标7的元素（不包括下标7的元素）,每两位取一位
    print(s3)	#aceg

	#截取全部，返回新的字符串对象
	s4 = s[:]
    print(s4)	#abcdefghjkiuytyt

	#倒叙输出字符串
    s5 = s[::-1]
    print(s5)	#tytyuikjhgfedcba

	#s6 = s[0:4:-1] 无输出
	#[start,end,step] 
	#当step为负数时，最后一个元素的下标值要大于end
	#当step为整数时，最后一个元素的下标值要小于end
	#step默认为1
	
	#字符串常用方法
	print(s.capitalize()) #返回一个首字母大写的新字符串，原字符串不变
	print(s.upper())	#返回一个所有字母大写的新字符串，原字符串不变
	print(s.lower()) #返回一个所有字母小写的新字符串，原字符串不变
	print(s.isupper())	#判断字符串是否全大写，返回True或False
	print(s.islower())	#判断字符串是否全小写，返回True或False
	print(s.swapcase())	#大小写翻转，将字符串大写的变小写，小写的变大写
	print(s.title()) #将空格或特殊字符后的单个字符转为大写
	print(s.center(10, '*'))	#将字符串居中展示，宽度为10，空白处填充*补满
	print(s.expandtabs())	#将字符串中的\t自动转为一个Tab键（1个Tab键表示8个空格）
								#\t前的字符自动填充到这8个空格中，不满的位置以空格代替
								#\t前的字符个数大于8,扩展8位存放,不够再扩展8位
								#不常用的方法,财务,报表可能用到
	print(s.startswith('ab',0,8)) #在下标0至8（不含8）的元素切片中判断是否以字符ab开头
									#切片范围可以不写;不写,默认就是全长
									#返回True或False
	print(s.endswith('ab',0,8)) #判断是否以什么字符串结尾

	print(s.find('bc')) #查找字符串,找到就返回下标;找不到,返回-1;可切片
	print(s.index('bc'))	#查找字符串,找到就返回下标;找不到,会报错;可切片
	
	print(s.strip('abt')) # 去除前后字符'a' ,'b' , 't' ,
							#不加参数，默认去除前后空格
	print(s.count('a'))	#计算字符串出现的次数
	print(s.split('g')) #拆分字符串，得到一个列表，这是字符串与列表转换的方法，也是字符串拆分最常用方法
						#没有参数，默认以空格拆分
	print(s.isalnum())	#判断是否由数字或字母（两种或1种）组成 ， 返回True或False
	print(s.isalpha())	#判断是否由纯字母组成
	print(s.isdigit()) #判断是否由纯数字组成
	s='abcgdjfhk'
    print(s.replace('b', 'kkk', 1))	#字符串替换 ，参数1旧字符，参数2新字符，参数3替换次数
    print(s)
	
	 #字符串格式化输出
    s='name为{},年龄为{}'.format('张三', 21)
    print(s)	#name为张三,年龄为21
    #字符串中{}为占位符，利用format将值传入对应的位置

	 li = ['张三', 167,21]
    #字符串格式化输出
    s='name为{0},年龄为{2},身高为{1}'.format(li[0],li[1],li[2])
    print(s)	#name为张三,年龄为21,身高为167
    #根据参数下标来赋值format(参数下标0，参数下标1，参数下标2)

	li = ['张三', 167,21]
    #字符串格式化输出
    s='name为{n},年龄为{a},身高为{h}'.format(n = li[0],h = li[1],a = li[2])
    print(s)	#name为张三,年龄为21,身高为167
    #按关键字传参
	
	str1='abc'
	print('%s'%str1) # %s 表示一个字符串类型的占位符,使用%后面的str1变量替换这个占位符
	# %f 表示 float类型的占位符
	# %.2f 表示保留2为小数的float