Python01_变量类型与基本语法

Python01变量类型与基本语法

python可以使用缩进来代表代码块不需要{}，d但同一个代码块的缩进空格必须保持一致。

在python里，所见的一切皆为对象，皆为对对象的引用。

​ 我们创建变量时，在python里是这样运行的：举例a=3，python首先创建变量a,其次创建一个对象存储3，最后通过指针将变量a和存储3的对象连接起来即为引用

变量类型

标准数据类型

number、string、list、tuple、dictionary、set（数字、字符串、列表、元组、字典、集合）

数字NUMBER

int、float、bool、complex（整形（包含了长整型）、浮点、布尔、复数）

复数由实部和虚部组成表象形式=a+bj，虚部用j或者J进行表示

数字类型转换

int(x)
float(x)
complex(x)
complex(x,y)#转换到复数，x为实部y为虚部

运算

#除法运算可以丢弃浮点部分
print(17//3)
#此结果数据类型与分母分子的数据类型有关系

#在只读模式里_变量被用户视为只读变量

运算函数(math)

#取整
math.ceil()#上取整
math.floor()
#运算
math.exp(2**3)#返回2
math.fabs()#返回数字绝对值
math.log()#返回幂次math.log(100,10) =2
math.log10()
#math.modf()
print(math.modf(2.1))#返回整数和小数部分，类型是元组
print(type(math.modf(2.4)))  

math.round()#浮点数四舍五入，参数两个，浮点数x和取整位数
#math.round(math.pi,3) 3.141
math.sqrt()#返回平方根

随机数（random）

基础

import random
#使用随机数必定导入
#建议使用所有随机数前调用seed重新生成种子

print(random.choice([1,2,3,4,5,6,7,8,9]))
print(random.choice(range(10000)))
print(random.choice("runcosnb"))
print(random.choice((1,2,"jkl","23","ll")))
#返回随机列表、集合、元组，字符串里字符或者范围内随机数
#print(random.choice({'ui':0,'iii':9}))好像不能随机字典


random.randrange(x,y,z)#三个参数，依次为x随机数起始位置，随机数结束位置y，递增计数z
print(random.randrange(1,10,3))#用白话讲，可以理解为生成满足y%z=x的范围内的随机数

#随机生成实数 吧
random.uniform(x,y)

#将序列元素随机排列
list2=[1,2,4,555,644,34]
random.shuffle(list2)
print(random.shuffle(list2),type(list2),type(random.shuffle(list2)))#random.shuffle(list2)，是在序列内部排序自己不做存储没有返回值
print(list2)
#None <class 'list'> <class 'NoneType'>
#[1, 34, 4, 555, 644, 2]

shuffles序列所有元素排列

#shuffles具有破坏性，需要每次重置列表，这导致在同一个种子下随机出来的序列是不相同
import random
list2=[1,2,4,555,644,34]
random.seed(100)
random.shuffle(list2)
print(random.shuffle(list2),type(list2),type(random.shuffle(list2)))
print(list2)

random.seed(100)
random.shuffle(list2)
print(random.shuffle(list2),type(list2),type(random.shuffle(list2)))
print(list2)

random.seed(100)
random.shuffle(list2)
print(random.shuffle(list2),type(list2),type(random.shuffle(list2)))
print(list2)

#目前在pcgram里可以通过将当前的list转存给另外一个list2，用list2展示打乱后结果是可以相同的

字符串STRING

python里字符串是通过索引查找对应字符

假设当前runoob为字符串，拿取其中字符有两种，索引或截取

从前面索引是0-5，从后面索引是-6到-1.

从前面截取是1-5，后面截取是-5到-1

str="runoob"
#后面索引 -6 -5 -4 -3 -2 -1
#前面索引 0 1 2 3 4 5
#前面截取 :1 2 3 4 5 :
#后面截取 :-5 -4 -3 -2 -1 :
print(str,str[0],str[-5],str[1:5],str[-5:-1])
print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str)
#str[-6:],从第一个开始截取
#字符串，字符串第一个字符，字符串索引第二个字符，字符串前面截取通过第1字符到第五个字符，字符串后面截取通过第5字符到第1个字符

python没有其余的字符类型，一个字符就算一个长度为1的字符串

str="runoob"
print(str[0],str[5],str[-6],str[-1])

格式化字符串%

print("fuck the %s %d years" % ('python',3))
print("fuck the %s %d years %d" % ('python',3,0x26f))
#参考C语言输出

符 号	描述
%c	格式化字符及其ASCII码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f和%e的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地

三引号（允许字符串跨越多行）

所以这个针对跨行的测试代码超级实用（sql\html）

str="""jkkkk
shjhdjf ksakhj \a shjd\' dhhjkfhsj\th jkhsjkhj\n
absdhsdjka"""
print(str)
#jkkkk
#shjhdjf ksakhj  shjd' dhhjkfhsj	h jkhsjkhj
#
#absdhsdjka

新特性f-string格式化字符串

#!/usr/bin/python
#_*_coding: UTF-8 _*_
name = 'test01'
print(f'hello python fstring {name}')

x = 1
print(f'{x+1=}')   # Python 3.8
x+1=2

内嵌函数

str="shdjk"
print(str.capitalize())#首字母转换为大写

#str.center(width,'填充字符') 指定宽度，返回一个宽度居中的字符串，填充字符只能为单个字符不能为字符串.填充规则，不能完全居中的，右边多
str.center(10,'*') #**shdjk***


#查找某个字符串或字符出现次数count，三个参数，搜索字符串，搜索起始位置，搜索结束位置.搜索字符串必须是在被搜索字符串内是连接，不能有其他字符打断
str="shdjk"
print(str.count('k',4,5))#输出1
print(str.count('dk',0,5))#输出0
print(str.count('jk',0,5))#1

#检测某个字符串是否在某个字符串内（可以指的那个范围）
  str="shdjk"
  print(str.find("hhd",0,5))
  print(str.find("hd",0,5))#找到返回1，输出1，没找到返回-1输出-1
  #str.index()与find用法一致，但是他找不到回报异常
  print(str.index("jjj",0,5))
  #Traceback (most recent call last):
  #File "C:\ProgramEdit\pythonProject\202112245_03\test02.py", line 29, in <module>
  # print(str.index("jjj",0,5))
  # ValueError: substring not found

#修改编码的bytes.decode(),参数以此为要使用的编码，以及编码错误的处理方式
str="时间很紧"
uncode1="utf-8"
uncode2="gbk"
uncode3="us-ascii"
u1=str.encode(uncode1)
u2=str.encode(uncode2)
#u3=str.enco  de(uncode3)
u3=u2.decode(uncode3,'strict')
print(u1,u2,u3) #执行会报错u3超范围，因为是ascii


#字符检查函数
  #检查字符串是否由纯数字或字母组成 str.isalnum(),返回类型boolean
  #检查字符串是否由纯文字（中文法文？）或字母str.isalpha().返回类型boolean
  #检查字符串是否由纯数字str.isdigit().返回类型boolean
  #字符串中若有字母，检查字母是否都是小写str.islower().返回类型boolean
  #字符串中只含有数字或者数字字符，str.isnumeric().返回类型boolean
  #检查字符串是否只空白，str.isspace().返回类型boolean
  #指定分割字符，通过此字符进行连接
    s=" "
    str=['a','b','c','d','l',' ','5']
    print(s.join(str))#a b c d l   5
  #lower转换所有字符变成小写
   print(str.lower())
    
#截取分隔符对字符串切片str.split()
  #参数一分隔符，参数二分割次数，不传递分割次数就默认全部分开
    str = "this is string example....wow!!!"
    print (str.split( ))       # 以空格为分隔符 ['this', 'is', 'string', 'example....wow!!!']
    print (str.split('i',1))   # 以 i 为分隔符['th', 's is string example....wow!!!']
    print (str.split('w'))     # 以 w 为分隔符['this is string example....', 'o', '!!!']
    
#转换函数
  str.swapcase()#字符转换函数

列表list(有序对象的集合)

与字符串一样可以被索引或者截取，但需要用逗号分隔开元素列表。

支持三个参数，第三个参数为步长：如当前我要索引1到4之间步长为2的值，则str[1:4:2]

可以通过+连接运算符，*重复操作

list =['12','2','3','4']
list2=['23','34','56']
print(list2[2:]*2+list,list)
#['56', '56', '12', '2', '3', '4'] ['12', '2', '3', '4']

def function_fullback(input):
    input2 = input.split(" ")
    #以某一个字符为基准，拆分字符串为列表
    input2=input2[-1::-1]
    #列表截取从最后一个开始到第一个结束，步进-1，逆向读取截取
    print(input2)
    out =' '.join(input2)
    #join以某一个字符将列表链接成字符串，这里用' '进行连接
    return out
if True :
    input = 'fuck python alright'
    rw = function_fullback(input)
    print(rw)

#列表元素操纵函数
del list[0]

#末尾添加列表、元组、集合
 #添加一个对象元素list.append()
 #添加多个对象元素list.extend()
   list1=['1',2,3]
   tuple2=(4,5,6,7)
   set2={8,9,10,11}
   list1.extend(tuple2)
   print(list1)
   list1.extend(set2)
   print(list1)
   #['1', 2, 3, 4, 5, 6, 7]
   #['1', 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
    
#移除元素
  #移除位置上元素对象，然后返回移除的值
  list1 = ['90hjhjk', 2, 3]
  print(list1.pop(0))#90hjhjk
    
  
  #移除指定元素del list[0]
    list1 = ['90hjhjk', 2, 3]
    del list1[0]
    print(list1.pop(0))#是将对象直接删除，第一位置指针指向第二位置
    
  #清空列表 list.clear()

#list.copy() 复制列表

元组tuple

元组区别去列表list，用（）进行分割，而不是[],且元组内元素不能修改，用法与列表一样可以索引，截取，步进+和*等

元组无法删除元素，所以只能通过删除整个元组来进行删除操作

tuple01=()#创建空元组

#元组中只包含一个元素时，需要再加一个逗号否则对当作运算符使用
tuple3= (50)
tuple4 = (50,)
tuple5 = ('jkl',)
tuple6 =('jkl')
print(type(tuple3),type(tuple4),type(tuple5),type(tuple6))
print(5+tuple3,'45'+tuple6)
#<class 'int'> <class 'tuple'> <class 'tuple'> <class 'str'>
#55 45jkl

#内嵌函数
  #将其余迭代系列转换为元组 tuple()

集合set（无序不重复元素序列）

使用{}创建集合，空集合必须使用set()，而非set{},否则创建的是一个字典，集合会自动去重

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites) 
#实际观察sites集合输出时，每次输出的不一样，是随机的

元素添加site.add(元素)#添加的元素已存在则不进行任何操作

#update  也可以进行添加元素，不限于元组、字典、列表等
str.update(x,[],(),{})
#remove移除元素，将元素从x中移除，移除元素不存在会发生报错
#len计算元素个数
#clear清楚所有元素

#判断元素是否在集合中
x in set1

字典dictionary（无序对象的集合）

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。键值对

字典支持更新键值对的值

同样支持单个删除字典内容

del dict['name']

dict={}
dict['ome'] = "1--ioioi"
dict['jkl'] = "2-duizi"

dictionary ={'name':1,'name2':2,'name3':3}
print(dictionary.keys())
print(dictionary.vlaues())
#输出结果 name name2 name3
#1 2 3


#创建字典
dict{a='a',b='b',c='c'}
#查询字典长度 dict.len()

#内嵌函数
 #clear()清楚字典元素的函数
 #拷贝函数copy,这里的拷贝与直接赋值不一样。一般字典的赋值是直接引用，即源字典发生变化，引用的也发生变化；而使用的copy则不会发生改变，还是原来的值，即为深拷贝
dict01 = {1:1,'1':22,3:'jhkl','565':22}
dict02=dict01
dict03=dict01.copy()

print(dict01)
del dict01[1]

print(dict01)
print(dict02)
print(dict03)
#{1: 1, '1': 22, 3: 'jhkl', '565': 22}
#{'1': 22, 3: 'jhkl', '565': 22}
#{'1': 22, 3: 'jhkl', '565': 22}
#{1: 1, '1': 22, 3: 'jhkl', '565': 22}

查询变量类型函数

isinstance(变量名，比较的变量类型)与type(变量名)
#isinstance返回值是boolean类型，type直接返回变量类型名称
#区别
#isinstance会认为当前变量是某一个父类的子类类型；type会认为当前变量自己就是一个父类，所以type不能判断变量是否其余类的子类

class A:
    pass
class B(A):
    pass
print(isinstance(A(),A),isinstance(B(),A))
print(type(A()),type(B()))

#结果
#True True
#<class '__main__.A'> <class '__main__.B'>

进制转换函数

oct()#8进制转换
print(oct(8))#012
hex()#16进制转换
print(hex(255))#0xff

类型实际属于对象，而非变量

a=1
a=10.0
a='asd'
#这里看着是是a类型发生改变，但实际是创建了三个对象，而a的指针最后指向了存储asd的对象，不删除对象的话1和10.0的对象是不会消失的
#python自带对象垃圾回收装置，当存储值的某一个对象不被引用后，此对象空间自动放入自由空间池等待后来对象使用

在python里，所见的一切皆为对象，皆为对对象的引用。

​ 我们创建变量时，在python里是这样运行的：举例a=3，python首先创建变量a,其次创建一个对象存储3，最后通过指针将变量a和存储3的对象连接起来即为引用

https://www.cnblogs.com/my_captain/p/9063224.html

转义字符

/t 空格

print(hello\tworld)
print(helloooo\tworld)
#是有不同的空格，实际观察第一空3格，第二个空四格
#字表位是四个为一位置，第一个hello\tworld中，hello占一个字表位，而o占了一个字表位中的一个位置，而剩下的3个位置被\t所取代
#第二个hell、oooo各自占据一个字表位，空格\t没有位置了所以单独占据一个字表位的所有位置

\r覆盖（回车）

print('hello\rworld')
#hello会被world覆盖掉，准确说是\r之前的全被wrold覆盖.光标置会开头，重新输入

\b退格（）

print('hello\bworld')
print('hello123123\b\b\b\b\bworld23')
#输出hellworld,o被干掉了.光标前移一位

\\ 输出斜线
print('http:\\\\')
#同理
\'
\"

取消转义字符

print(r'hello\rworld')
#输出前+r可以取消转义字符

python字符串背后不能用反斜线，会报错

print(r'hello\rworld\')
#下面可以，还是因为转义字符
print(r'hello\rworld\'')

\a 电脑执行后有响声

\000 null

\f 换页

输出与输入

print函数本质上是一个回车，所以想要多个print不用回车的话需要添加end=“”

x="a" ;y="b"
print(x)
print(y)
print(x,end=" ")
print(y,end=" ")

Python导入函数和其余模块

import与from import

导入整个模块import +模块

导入模块中某一个函数 from 函数名 import 模块名

导入模块中多个函数 from module import function1,function2,…

将某个模块中的全部函数导入，格式为： from somemodule import

运算符

运算符与其他编程语言没有大区别

** 返回幂次数

a=3 b =2
print(a**b)#9

:=海象运算符

表达式内部变量赋值专用

位运算

python的位运算是先将数字看成二进制，然后根据二进制的0或者1去进行计算

左移 数字<<移动位数，二进制整体向左移动。

右移 数字>>移动位数，二进制整体向右移动。

逻辑运算符

and、or 、not

成员运算符

in 如果在指定的序列中找到值返回 True，否则返回 False。

not in 如果在指定的序列中没有找到值返回 True，否则返回 False。

用于列表、字典、集合等查找字符是否在位置上

#!/url/bin/python
a=10
b=20
list = [1,2,3,4]

tinydict = {'name': 'runoob','code':2, 'site': 'www.runoob.com'}
setlist=('123',2,3,5)
list=['23','sad',2]

if 'code' not in tinydict:
    print('notinthedic')
else:
    print('inthesation')

if 6 not in setlist:
    print('notinthedic')
else:
    print('inthesation')

if 2 not in list:
    print('notinthedic')
else:
    print('inthesation')

身份运算符

用于比较两个对象的存储单元

#is
#is not

python的编程新特征

复合赋值

#!/usr/bin/python3
a,b=0,1
while b<10
 print(b)
    a,b=b,a+b
#    如上a,b=0,1分别将0赋值给a,1赋值给b
#下面的a,b=b,a+b，会先以赋值前的ab进行计算然后再将ab进行赋值
#举例循环开始a=0,b=1,进入第一次循环执行a,b=b,a+b,执行后此时a=1,b=1

end循环结果输出之同一行,后面跟着同一行输出的分隔符

a,b=0,1
while b<1000
  print(b,end=' ')#这里用空格分开
  a,b=b,a+b
  #1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

条件控制语句

#python中是通过缩进来进行判断是否是同一个代码块的所以控制语句的缩进必须保持一致
if cos1:
    print()
elif cos2:
    print()
else:
    print()

循环语句

while循环

while cos1:
   print()

#while支持else,在while结果为false时会执行else
while cos1:
    print()
else:
    print()
    
#while若是只有一行，可以跟while在同一行
x=1
while x>=3: print("x")
    

for循环

for也有else语句，千万注意，一般迭代序列for效果比while好

#遍历可以迭代的对象 
site01 ={'sad','asd','uoi','sajdkl'}
for sit in site01: print(sit)

tinydict = {'name': 'runoob','code':2, 'site': 'www.runoob.com'}
for sit in tinydict: print(sit)
#4 name code site


#生成数列的range,用法不在赘述
for i in range(1,100,4):
  print(i)
for i in range(10,100,4):
  print(i)

break和continue

不多赘述

pass语句

空语句，主要目的为保持程序结构的完整性

x=0
y=100
for i in range(x,y,20):
  if i!=60 :
    print(i)
  elif i!=80 :
    pass
    print("pass hrer")
  else:
    print('end')
#0
#20
#40
#pass hrer
#80

python的迭代器与生成器

迭代器

访问集合元素的方式，本质还是创建一个对象存储元素然后指向这个对象元素，但是可以记住遍历对象的位置，迭代器只能往前不能回退。

迭代器停止一般要catch StopIteration异常

#基本方法inter() next()
list03=[1,2,3,4,'sjh','hj']
list03_iter= iter(list03)
for iter01 in list03_iter:
  print(iter01,end=' ')
#1 2 3 4 sjh hj 

在python中类也可以创建迭代器，但是需要单独创建两个方法_next_()和_iter_

class testclass:
  def __iter__(self):#双下划线
    self.a = 1
    return self
  def __next__(self):
    x = self.a
    self.a+=1
    return x

clas01 = testclass()
myiter = iter(clas01)
y=1
while y<=10:
  print(next(myiter),end=',')
  y+=1
    #1,2,3,4,5,6,7,8,9,10,
    
#迭代器可以自定义出现循环次数__next__方法里定义循环次数然后出发stop iteration结束循环
class testclass_iter:
  def __iter__(self):
    self.a=1
    return self
  def __next__(self):
    if self.a<=5:
      x=self.a
      self.a+=1
      return x
    else:
      raise StopIteration
class01= testclass_iter()
myiter = iter(class01)
for x in myiter:
  print(x,end=' ')

生成器

凡是在函数内使用yeild的统统成为生成器，生成器本身是一个迭代器，是一个返回迭代器的函数

#使用生成器需要导入sys
#!/usr/bin/pyhton3

import sys
import sys
def fibonacci(n):
  a,b,concurrent=0,1,0
  while True:
    if (concurrent >n):
      return
    yield a#生成器在运行过程中每次遇到yeild都会暂停并保存当前所有运行信息，返回yeild的值，同时在下一次迭代器next操作时从当前位置继续运行
    a,b=b,a+b
    concurrent+=1
f=fibonacci(20)
while 1==1:
  try:
    print(next(f),end=' ')
  except StopIteration:
    sys.exit()
    #0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 

python自定义函数

#def开头后面接函数标识符和(),函数结束必须要return,形式参数放在()内，:结束
def function(sybstring1,substring2,list):
    return 

#参数传递
#python中类型属于存储数据的对象，任何变量在不指向对象的情况下都是无类型的，就是指向了对象也是无类型的，所能获取的对象都是数据对象的类型
#python函数形参分为不可变类型（整形、字符串等）和可变类型（列表、字典、集合）
  #不可变类型：传递的时值没有影响存储数据的对象本身，就算内部修改也只是换成了新的对象，不影响传入的
  #可变类型：包括变量在内全部传递进去，变量本身所指向的对象修改了。内部修改后外部也会随之改变会影响外部的其他使用


print()
list03=[1,2,3,4,'sjh','hj']
def function01(list):
  del list[1]
  print(list)
  return
print(list03)
function01(list03)
#[1, 2, 3, 4, 'sjh', 'hj']
#[1, 3, 4, 'sjh', 'hj']

参数类型详解

#关键字参数 与函数调用紧密连接，函数使用关键字确定传入的参数的值，就算声明和调用顺序不对python解释器也能通过参数名匹配上，所以使用前提时参数名的关键字不能发生改变
def prinme(str):
    print(str)
    return
prinme(str = "454545")

  #不按照声明顺序给予关键字值
print()
def function03(age,name,we):
  print(age,name,we)
function03(name='54545',we='jhks',age='45')

#默认参数 没传递参数就默认使用
def function04(age=3,name='jkl'):
  print(age,name)

function04()
function04(4,'5555')
#3 jkl
#4 5555

#不定长参数 当一个函数无法确定他即将处理多少传入参数时使用
def printinfo( arg1, *vartuple ):
    #*vartuple是导入的未命名参数，多出来的参数会一起存在名为vartuple的元组所指定的对象内部
    #没有指定参数的话，默认是一个空元组，不会打印任何东西
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
 # 调用printinfo 函数
printinfo( 70, 60, 50 )
#70
#(60,50)

#带两个**的默认是字典形式导入也属于不定长参数，所以传入时要采取字典键值对的方式传入
#!/usr/bin/python3
  
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
 
# 调用printinfo 函数
printinfo(1, a=2,b=3)

匿名函数

#python使用lambda来创建匿名函数，不在使用def进行声明，主体只是一个表达式，而不是自定义函数的代码段形式展现，所以只能封装少量的逻辑表达

sum = lambda arg1,arg2:arg1 + arg2 + arg2*arg1
print(sum(1,4))
#9

return

退出函数必须使用，就跟java、c的使用方式一样。

强制位置参数（3.8）

def f(a, b, /, c, d, *, e, f):
    print(a,b,c,d,e,f)
    #a,b必须使用指定位置形参
    #c或者d使用位置形参或关键字形参都可以
    #e和f要求为关键字形参

def function05(/,a,b):
  print(a,b) #是不正确的写
  
def function05(a,b,*,*jjj):
  print(a ,b , jjj)
function05(10,20,40,50,jjj=60)  #不定长放在前面