python学习１

#科学计数法
#3.34e2 == 3.34 X 10的2次方(相当于x100)　＝　334.0
#3.34e-2 == 3.34 X 10的-2次方(相当于x0.01)　＝　0.0334
复数类型
用complex函数创建复数

//有短路功能测试
a=1
b=0
def f1():
print(“entry f1 function”)
return True
print(a print(a>b and f1())
print(a

按位取反公式
~a=(a+1)*(-1)

if语句的使用
//单分支
age=5
if age>=3:
print(“可以上幼儿园了”)
print(“学习不知道好不好”)

//双分支
uName=input(“请输入用户名：”)
passWard=input("请输入密码: ")
if uName == “jiang” and passWard == “123”:
print(“输入正确，登录成功！”)
else:
print(“输入错误，请重新输入”)

//多分支(注意elif书写，不是C语言的else if)
score=int(input(“请输入你的会员积分：”)) #转换为int类型
if score==0:
print(“注册会员”)
elif score > 0 and score < 200:
print(“铜牌会员”)
elif score >= 200 and score < 500:
print(“银牌会员”)
elif score >= 500 and score < 1000:
print(“金牌会员”)
else:
print(“钻石会员”)

//嵌套if语句
idCode=input("请输入省份证号码: ")
if len(idCode) == 18:
number = int(idCode[-2])
if number % 2 == 0:
print(“女性”)
else:
print(“男性”)
else:
print(“输入错误”)

//循环
count=0
num=0
while count < 100:
count += 1
num = num + count
print(“1-100的和是:”,num)

//无限循环
while True:
num = int(input("请输入一个数字: "))
print("你输入的数字是: ",num)

//while和else组合使用
count=0
while count < 5:
print(“count :”,count)
count += 1
else:
print(count,“大于或等于5”)

//for循环,(可迭代的)
for 临时对象 in 可迭代对象:
执行语句
执行语句
languages = [“C”,“C++”,“python”,“Java”]
for x in languages:
print("当前语言是: ",x)

for i in range(6): #range内置函数,生成一个数列
print("当前数列是: ",i)

for i in range(3,7): #range一个区间
print("当前数列是: ",i)

//99乘法表:
for i in range(1,10):
for j in range(1,10):
if j <= i:
print(f’{j} {i}={i*j}’ , end=‘\t’)
print()

//跳转语句(break),通常结合if判断语句使用
for s in “hello”:
if s== ‘l’:
break
print("当前字母是: ",s)

//双重循环和break的配合使用(判断质数)
for n in range(2,10):
for x in range(2,n):
if n%x == 0:
print(n,“等于”,x,“*”,n//x)
break
else:
print(n,“是质数”)

//跳转语句(continue)
for x in [0,-2,5,7,-10]:
if x <= 0:
continue
print(x)
重点:break和continue只能在循环语句里面使用

//pass(空语句，也叫站位语句)
主要是保持程序的完整性

//python容器类型数据
//序列,包括字符串，列表，元组，集合，字典等(相当于数组)
a = “Hello”
print(a[1])
print(max(a))
print(min(a))
print(len(a))

//容器的加和乘操作('+'两边的类型必须相同)
a = “Hello”
print(a + " world")
print(2*a) #hellohello

//容器－>切片操作
sname[startstep]
str=“hello world”
print(str[:2]) #从0开始，切2个字符
print(str[::2]) #从0开始，到最后结束,步长是2
print(str[:]) #全部截取

//成员测试运算符 in 和not in
str = “hello”
if ‘e’ in str:
print(“e in str”)
if ‘E’ not in str:
print(“E not in str”)
print(‘e’ in str)

//列表的两种创建方法 []和list函数
listOne=[] #空列表
listTwo=[2,3,4,6]
listThree=[1,‘a’,“aaa”,4.5] #元素类型可以不同
for i in listThree:
print(i)
print(type(listThree[3]))

//list函数创建列表
#listOne=list(1) #错误,必须是可以迭代的
listTwo=list(“python”)
print(listTwo)
listThree=list([1,“hello”,1.23])
print(listThree)

from collections import Iterable
print(isinstance(listThree,Iterable)) #判断是否是可迭代对象的方法

//容器追加元素
l=[20,3,5]
print(l)
l.append(56)
print(l)
l2=[55,32]
l.extend(l2)
print(l)

//容器插入元素
name=[“zhangsan”,“lisi”,“wangwu”]
name.insert(2,“jiangxiaoer”)
print(name)

//替换元素
name=[“zhangsan”,“lisi”,“wangwu”]
name[1] = “jianghuaiwei” #替换
print(name)

//删除元素
删除列表元素的方法有del语句，remove()方法,和pop()方法;
//del语句
name=[“zhangsan”,“lisi”,“wangwu”]
del name[2]
print(name) #[‘zhangsan’, ‘lisi’]
//remove函数
name=[“zhangsan”,“lisi”,“wangwu”]
name.remove(“lisi”)
print(name)
//pop函数
number=[1,2,3,4,5]
print(number.pop()) #不指定，则移除最后一个元素
print(number)
print(number.pop(2)) #移除第二个元素
print(number)

//元组的创建
元组是一种不可变序列类型
元组创建方法和列表的创建方式相同
tupleOne=()
tupleTwo=(1,2,3,3,4)
tupleThree=(2,“hello”,3,44) #元组的元素类型可以不同
print(tupleThree)
//另一种创建元组方法
tupleA = tuple(“hello”)
print(tupleA)

//元组拆包
元组拆包，就是把元组的元素赋值给对应的变量
val = (10,20)
a,b=val #元组拆包,元素的个数和变量的个数必须相同
print(a)
print(b)

//集合
//集合是一种可迭代的，无序的，不能包含重复元素的容器
//集合分为可变集合和不可变集合
setOne = set((1,2,3,3)) #用元组创建集合
setTwo = set([1,2,3,3]) #必须有set关键字,用列表创建集合
print(type(setOne))
print(type(setTwo))
print(setTwo)
setThree = {1,2,2,4} #用{}创建集合
print(setThree)
setFour = frozenset([1,2,3]) #不可变集合
print(setFour)

//集合添加元素
setOne = set()
setOne.add(“py”) #添加元素
setOne.update(“jiang”) #添加多个元素,字符串的每个字符作为一个元素
print(setOne)

//集合删除元素
remove discard pop等3种方法删除元素
setOne={1,2,4,5,6}
setOne.remove(4)
#setOne.remove(4) 再次调用会出错
print(setOne)
setOne.discard(2)
setOne.discard(2) #再次调用不会出错
print(setOne)
setOne.pop() #删除某个随机元素
print(setOne)
setOne.clear() #清空元素
print(setOne)

//字典
用{key1:value1,key2:value2,…}创建字典
dict1 = {“key1”:“jiang”,“key2”:“suhui”} #第一种创建字典方法
print(dict1)
score = {} #
print(type(score))
dict2 = dict(name=‘a’,age=‘b’) #使用dict内置函数创建字典
print(dict2)
//dict创建字典，可以接收的参数包括(字典，元组，列表),作为参数可以创建字典

//修改字典(包括添加，修改，删除)
dict1 = {“key1”:“jiang”,“key2”:“suhui”}
dict1.update(k3=“huang”) #update添加,注意k3没有引号
print(dict1)
dict1[“k4”] = “zhang” #第二种添加方法
print(dict1)
dict1[“key1”] = “yuhaizhi” #修改元素
print(dict1)
#pop,popitem,clear等成员函数，删除字典元素
dict1.pop(“key2”) #删除方法1
print(dict1)
dict1.popitem() #删除方法,随机删除元素
dict1.clear() #清空元素
print(dict1)

//字典元素访问
//可以访问所有的item,所有的key，所有的value
info = {‘001’:“jiang”,‘002’:“suhui”}
print(info.items()) #dict_items([(‘001’, ‘jiang’), (‘002’, ‘suhui’)])
for i in info.items(): #(‘001’, ‘jiang’) (‘002’, ‘suhui’)
print(i)
print(info.keys()) #dict_keys([‘001’, ‘002’])
for i in info.keys():
print(i)
print(info.values()) #dict_values([‘jiang’, ‘suhui’])
for i in info.values():
print(i)

//字符串的学习
//普通字符串
str = ‘hello"aaa’#内部如果用双引号，则外侧要用单引号,发过来也是
print(str)
str2 = ‘\u0048’
print(str2) #输出’H’
//原始字符串(以字母r或者R作为前缀的字符串，如R’‘或者r’‘,则称作为原始字符串)
str2 = r’\u0048’ #里面的’‘不具有转义字符的功能,主要用于[路径]的解析
print(str2) #\u0048
//长字符串
使用三个单引号’‘‘或者3个双引号"""括起来;
str = ‘’’
床前明月光，疑是地上霜；
举头望明月，低头思故乡。
‘’’
print(str)

//字符串转换为数字
a = int(“10”)
print(type(a))
a = int(“ab”,16) #按16进制转换
print(a)
//数字转换为字符串(str是内置函数)
a = str(12)
print(type(a))
a = str(True)
print(a) #输出True

//格式化字符串
python的字符串可通过占位符%,format()方法和f-string三种方式实现格式化字符串输出;
(占位符的使用)
name=“小强”
print(“你好，我叫%s” %name) #占位符的使用
age = 20;
print(“你好，我叫%s,年龄%d” %(name,age)) #多个占位符使用
(format的方法)
使用format，不需要关注变量的类型,格式如: <字符串>.format(<参数列表>)
name=“小强”
age = 20
print((“你好，我叫{},今年{}岁了”).format(name,age)) #format的使用
print((“你好，我叫{1},今年{0}岁了”).format(name,age))#另一种方式是通过参数占位符匹配输出
//format还可以对数字进行格式化，包括保留n位小数，数字补齐和显示百分比;
(1)保留n位小数,格式:{:.nf}
pi = 3.1415926
print(“{:.2f}”.format(pi)) #3.14
(2)数字补齐
n = 1
print(“{:0>3d}”.format(n)) #001
(3)显示百分比
n = 0.1
print(“{:.0%}”.format(n)) #10%
(f-string方法)
addr=“beijing”
age=20
print(f’欢迎来到{addr},age is {age}')

//字符串拼接
addr=“beijing”
ip=“127.0.0.1”
print(addr+ip)
//字符串查找
str1=“abcdefg”
index=str1.find(“d”) #返回的是对应索引，如果没找到，返回-1
print(index) #3
index=str1.find(“d”,1,3) #在1到3之间查找
print(index) #-1
//字符串替换　
word=“我是小强，我今年20岁”
new1 = word.replace(‘我’,‘他’) #所有的"我"都替换为"他"
print(new1) #注意，需要用新的字符串接收才可以
new2 = word.replace(“我”,“他”,1) #只替换一个
print(new2)
//字符串分割
#返回的是字符串列表
word=“1,2,3,4,5”
tmp=word.split(‘,’) #没有传递参数，默认以空格分割
print(tmp)
tmp=word.split(‘,’,3) #最大分割３次
print(tmp)
//去除字符串两侧空格
word=" strip "
tmp = word.strip() #默认以空格去除
print(tmp)
word=“aaabbb*”
tmp=word.strip(“*”)
print(tmp)

//python函数学习
def 函数名(参数列表): #def是关键字,必须有
函数体
[return 语句]
def fun(a,b):
return a+b
print(fun(3,4))
//无参函数
b=10
def area():
a=3 + b
print(“a is %d” %a)
return a
print(area()) #如果没有()，则调用的是函数地址
//函数的位置参数(好理解不赘述)，关键字参数，默认值参数，不定长参数(主要这四种)
#关键字参数
def info(name,age,addr):
print(f"姓名: {name}“)
print(f"年龄: {age}”)
print(f"地址: {addr}“)
print(info(name=“小王”,addr=“上海”,age=20))
#默认值参数
def info(name,age,addr=“南岗子”):#默认参数必须放到最后
print(f"地址: {addr}”)
print(info(name=“小王”,age=20))
#不定长参数
def fun(*args): #元组的形式
print(args)
fun(1,2,3,‘a’,‘b’) # (1, 2, 3, ‘a’, ‘b’) 以元组的形式输出
def fun(**args): #以关键字(字典)的形式
print(args)
fun(a=1,b=2,c=3,d=‘aaa’) #字典形式输出: {‘a’: 1, ‘b’: 2, ‘c’: 3, ‘d’: ‘aaa’}

//局部变量作用域
def fun():
name=“python”
print(name)
#print(name)#出了作用域
fun()
//全局变量
count=10
def Fun():
global count #如果修改全局变量的时候，必须用global 修饰下变量，否则会认为是局部变量
count += 10
print(count)
Fun()

//匿名函数(lambda [arg1,arg2]:expression)
area = lambda a,h:(a*h)0.5
print(area)
print(area(3,4))
//递归函数(递归必须有结束条件)
def factorial(num):
if num==1:
return 1
else:
return numfactorial(num-1)
print(factorial(5))#120
//常用内置函数
abs,len,help,ord,chr,filter(用于过滤容器，返回一个新的列表)