PYTHON基础二
一. 注释node
#python e:\py1\01.py
#python e:\Studypython\py2\01.pypython
print("444444444444444444444444444444444444444444444444444444444444444444444444444"mysql
# 单行注释sql
'''shell
这是多行注释
'''windows
二. print()输出api
#打印到屏幕上的一些信息 课题接受多个字符串
#用逗号分隔 遇到逗号会输出一个空格
#能够输出数字
#还能够运算数组
print("mysql name lickr , onckie function")
print(4+2)
print(8)
print("4+2=",6)
#print ()是输出函数app
三. input 交互 数据转换dom
# input
# 做用输入(阻塞)输入的内容保存在age
# int integer = 整数 把字符串转成int 用int(被转的数据)
# str string = 字符串 把数据转换成i字符串 用str(被转的数据)
# 注意 input 接受的全部数据都是字符串 即使你输入的数字 可是依然会当作字符串来处理
age=input("请输入你的年龄:")
print("age=",age)
四. python :如下是数据类型
number(数字)
整数
浮点数
复数
string(字符串)
布尔值(true/false)
none(空值)
list(列表)
tuple(元组)
dict(字典)
set(集合)
五. 标识字符
标识符(变量) : 是字符串(注意:字符串未必是标识符)
规则: 只能又数字字母下划线线组成
不能数字开头
不能使用python的关键字
区分大小写
见名知意
不能以数字开头
保留字符不能被使用的
变量名不能以大写英文字开头
在python 里不区分 变量(var)和常量 (const)
在python 全部都是可变的量
在python 中全部用所有大写的变量名来表明次变量为常量
做用: 给变量 函数等命名的
注意: 在python3中 非ascll标识符也是容许的 支持万国码 utf-8 undcode
在哪python 2.0以上打印中文 必须加上u 和字符集声明 在2.0 到2.9的版本只支持 Assic 默认编码
六. 变量与常量
程序是之上而下执行:
变量(var): 程序能够操做的存储空间
程序在运行期间能够改变的数据
每一个变量都特定的类型
做用: 将不一样的数据存储在内存中
列如: age=10
数据的存储 : 变量名=数据值
注意:变量必须先定义在使用
删除变量: del 变量名
删除后变量不能引用了
type() 查看数据类型
name=22
print(type(name)) 查看name数据类型
print(id(name)) 查看变量的地址
常量(const): 数据在运行的时候不能改变的量
在python 中全部用所有大写的变量名来表明次变量为常量
七. number 数据类型
# 分类 :整数 浮点数 复数
# 整数在python中能够处理任意大小的数字 在程序中和数学写法同样
# 单个定义变量
num22=10
num23=num22
# 连续定义多个变量
num=num1=num2=10
print(num,num1,num2)
#查看变量的地址
print(id(num1))
# 交互式赋值定义变量
num8,num9=6,7
print(num8,num9)
# 浮点数:由整数和小数部分组成 浮点数能够四舍五入
a=1.22
b=2.222
# 复数: 实数和虚数组成
a+bj
八. 数字类型转换
print(int(1.9)) # 1 将1.9浮点数转成整数1
print(float(1)) #1.0 将整数1转换成浮点数1.0
print(int("123")) #123 将字符串"123"转换成整数123
print(float("12.22")) #12.22 将字符串"12.22"转换成浮点数12.22
print(int("+123")) #123 注意: 正负号只能放在前面
print(int("-123")) #-123 若是有其余字符会报错
九. 数学功能函数
a=-100
a2=abs(a) #求绝对值
print(a2) #100
#比较两个数大小
b=100 #若是前面b>c 返回1 b<c返回-1 相等返回0
c=20
print((b>c)-(b<c)) #1
print(max(b,c)) #100 给定的参数返回最大的值
print(min(b,c)) # 20 给定的参数返回最xiao的值
#求x的5次方 2^5
print(pow(2,5)) #32 pow()求某某的n次方
#四舍五入round(x,[,n]) 返回浮点数x的四舍五入的值 若是给n值 则表明舍入到小
print(round(3.456)) #3
print(round(3.7)) #4
print(round(3.72228,2)) #3.72 后面那个参数表示保留几位
print(round(3.546,1)) #3.5 后面那个参数表示保留几位
#导入库
#库:封装了一些功能
#import math 意思就是导入数学相关的库
#math 数学相关的库
import math #意思就是导入数学相关的库
向上取整
print(math.ceil(17.9)) #18
print(math.ceil(17.1)) #18
向下取整
print(math.floor(17.9)) #17
print(math.floor(17.1)) #17
返回整数部分 和小数部分
print(math.modf(22.55555)) #(0.5555500000000002, 22.0)
print(math.sqrt(25)) # 5.0#开平方
import random #引入随机数模块
#随机数
print(random.choice([1,2,3,4,5,6])) #表示随机qu一个数组里面的数
#意思重数列中随机取一个
print(random.choice(range(5))) #意思生成1到5的数字
print(random.choice("ABCDEF")) #表示随机取一个数组里面的字母
#生产一个一到10的随机数
sui=random.choice(range(10))+1
print(sui)
# 从指定范围，按指定的奇数递增的集合中选取一个随机数
# random([start,],stop[,step])
# start 指定范围的开始值 包含在范围内
# stop 指定范围的结束值 不包含在范围内
# step 指定的基数
print(random.randrange(1,100,2)) #一到100的奇数 可是不包含一
print(random.randrange(100)) # 从0到100 取一个随机数 可是不包含100
print(random.random()) #生产0到1的随机数 可是不包含1 的浮点数
list=[1,2,3,4,5,6]
random.shuffle(list) #将list里面的数据 随机排序
print(list)
#随机生产一个实数 他在[3,9]范围
bb=random.uniform(3,9)
print(bb)
实列 : 数学函数简单彩票系统 import random #导入随机数模块 import math #到人数学模块 num=int(input("请输入你的号码:")) res=random.choice(range(100))+1 if num==res: print("你中奖了") else: print("你没中奖了")
十. 运算符
# 表答式: 有变量 常量和运算符组成的式子
# 阅读:表答式
# 功能：
# 值:
# 算术运算符和算术运算表达式
# 算术运算符
# + - * / % ** //
# 加 减 乘 除 取模 幂 取整
# 算术表达式:
num1=5
num2=3
print(num1+num2) # 8
print(num1-num2) # 2
print(num1*num2) # 15
print(num1/num2) #1.6666666667
print(num1%num2) # 2
print(num1**num2) #125
print(num1//num2) #1
赋值运算符 =
变量=表达式
aa=5
符合运算符
+= a+=b a=a+b
*= a*=b a=a*b
/= a/=b a=A/b
%= a%=b a=a%b
**= a**=b a=a**b
//= a//=b a=a//b
十一. if . for . while . break . 语句:
# 格式:
# if表达式:
# 语句
num=6
num2=7
if num==num2:
print("yes")
else:
print("no")
# -*- coding: UTF-8 -*-
# f 语句的判断条件能够用>（大于）、<(小于)、==（等于）、>=（大于等于）、<=（小于等于）来表示其关系。
# 当判断条件为多个值时，可使用如下形式：
# if 判断条件1:
# 执行语句1……
# elif 判断条件2:
# 执行语句2……
# elif 判断条件3:
# 执行语句3……
# else:
# 执行语句4……
num = 5 if num == 3: # 判断num的值 print 'boss' elif num == 2: print 'user' elif num == 1: print 'worker' elif num < 0: # 值小于零时输出 print 'error' else: print 'roadman' # 条件均不成立时输出
# 死循环 表达式永远为真的循环
while 2: print("哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈") var = 1 while var == 1 : # 该条件永远为true，循环将无限执行下去 num = raw_input("Enter a number :") print "You entered: ", num
# while 表达式:
# 语句
# else:
# 语句1
# 逻辑:在条件语句（表达式）为else时执行else的"语句2"
a=1 while a<=3: print("真的") a+=1 else: print("假的")
#练习if语句
aa=int(input("请你输入一个数是不是奇偶:"))
if aa%2==0:
print("是偶数")
else:
print("是奇数")
# aa=153%10 #3 各位 # aa=153//10 #15 # aa=153//10%10 # 5 十位 #aa=153//100 #1 百位 # #求水仙花树 num =int(input("请输入一个数:")) aa=num%10 bb=num//10%10 cc=num//100 if num==aa**3+bb**3+cc**3: print("是水仙花数") else: print("不是一个水仙花数")
#找最大值 num1=int(input()) num2=int(input()) num3=int(input()) max=num1 #假设 if num2>num1: max=num2 if num3>max: max=num3 print("max=",max)
# # 输出一到五的值: num=0 while num<5: num=num+1 print(num) # 1 # 2 # 3 # 4 # 5 # # 计算100一百的和 sum=0 num=1 while num<=100: sum+=num num+=1 print(sum) #5050 # # 打印字符串没一个 str="ABCDEFGAAAAAAAAAAA" index=0 while index<len(str): print( index,str[index]) index+=1 # 1 ==== B # 2 ==== C # 3 ==== D # 4 ==== E # 5 ==== F # 6 ==== G # 输出全部三位数的水仙花数 num=100 while num<=999: a=num%10 b=num//10%10 c=num//100 if num==a**3+b**3+c**3: print(num) num+=1 # 153 # 370 # 371 # 407 # 判断输入一个数是否是质数 # num=int(input("输入一个数是否是质数:")) # if num==2: # prin("是质数") # index=2 # while # 计算字符串的下标的和 # str=input("请输入字符串:") index=0 sum=0 while index<len(str): if str[index]>="0" and str[index]<="9": sum+=int(str[index]) index+=1 print(sum) 字符串比较大小是比的ASCII的值
# for 语句
# 格式:
# for 变量名 in 集合
# 语句
for aa in 'Python': # 第一个实例 print ('当前字母 :', aa) # 当前字母 : P # 当前字母 : y # 当前字母 : t # 当前字母 : h # 当前字母 : o # 当前字母 : n
fruits = ['banana', 'apple', 'mango'] for bb in fruits: # 第二个实例 print ('当前字母 :', bb) # 当前字母 : banana # 当前字母 : apple # 当前字母 : mango
# range() 函数 列表生成器
# 功能:生成数列
print(range(10)) #range(0, 10) for aa in range(5): print(aa) #0 1 2 3 4
for b in range(2,20,2): print(b) # # 2 # 4 # 6 # 8 # 10 # 12 # 14 # 16 # 18
# break语句用来终止循环语句，即循环条件没有False条件或者序列还没被彻底递归完，
# 也会中止执行循环语句。
# break语句用在while和for循环中。
# 注意只能结束最近的循环 就是当前循环
# 注意循环中能够有else语句 break致使循环截止 不会执行else里的语句
#!/usr/bin/python # -*- coding: UTF-8 -*- for letter in 'Python': # 第一个实例 if letter == 'h': break print ('当前字母 :', letter) # 当前字母 : P # 当前字母 : y # 当前字母 : t
var = 10 # 第二个实例 while var > 0: print ('当前变量值 :', var) var = var -1 if var == 5: # 当变量 var 等于 5 时退出循环 break # 当前变量值 : 10 # 当前变量值 : 9 # 当前变量值 : 8 # 当前变量值 : 7 # 当前变量值 : 6
# 注意循环中能够有else语句 break致使循环截止 不会执行else里的语句
num=1
while num<=10:
print(num) # 1 2 3
if num==3:
break
num+=1
else:
print("由于有braek就不会执行else中的语句")
# Python continue 语句跳出本次循环，而break跳出整个循环。
# continue 语句用来告诉Python跳过当前循环的剩余语句，而后继续进行下一轮循环。
# continue语句用在while和for循环中。
# 当前最近的循环
for letter in 'Python': # 第一个实例 if letter == 'h': continue print ('当前字母 :', letter) # 当前字母 : P # 当前字母 : y # 当前字母 : t # 当前字母 : o # 当前字母 : n #
var = 10 # 第二个实例 while var > 0: var = var -1 if var == 5: continue print ('当前变量值 :', var) # 当前变量值 : 9 # 当前变量值 : 8 # 当前变量值 : 7 # 当前变量值 : 6 # 当前变量值 : 4 # 当前变量值 : 3 # 当前变量值 : 2 # 当前变量值 : 1 # 当前变量值 : 0 #
十二. 运算符和表达式
# 位运行算
# & 按位与运算符
# 相应得位数都为1 则该为的结果是1不然为0
print(5&7)
101
111
-----
101
| 按位或运算符
两个二进制位有个位1时 结果为1
print(5|7)
101
111
------
111
^按位抑或运算符
二进制两位相异或
print(5^7)
101
111
----
010
~按位取反运算符
每一个二进制数据位取反
prin(~5)
<< 左移运算符
各二进制所有左移若干位 <<右侧的数字决定高位舍去低位补零
print(2<<2)
>>右位移运算符
各二进制所有右移若干位 由>>右侧数字决定
prin(13>>2)
十三. 关系运算符
== != > < >= <=
关系表达式
1+2>3+4
格式 : 表达式 关系运算符 表达式2
逻辑运算符
逻辑与 and
逻辑与运算符表达式 表达式1 and 表达式2
有一个为假就为假 其余为真
逻辑或 or
逻辑或运算符表达式 表达式1 or 表达式2
假假为假 其余为真 (有一个为真都为真)
逻辑非 not 逻辑非运算符表达式 or 表达式1
就假的说的真的 真的说成假的
短路原则
表达式1 and 表达式2 and 表达式3 and 表达式4.....and 表达式n
成员运算符
in 若是在指定的序列中找到了值返回true 不然返回fales
not in 意思在指定的序列中没有找到值返回true 不然返回fales
身份运算符
is : 判断两个标识符是否是引用同一个对象
is not ：判断两个标识符是否是引用不一样的对象
运算符优先级
**
~ + - (一元加减)
*/ % //
+ -
>> <<
&
<= < > >=
== !=
= %= += //=
is is not
in not in
#能被4整除 可是不能被100整除 或者 能被400整除 year=int(input("请你输入一个数字:")) if year%400==0 or(year%4==0 and year%100!=0): print("是闰年") else: print("不是闰年")
四十. 字符串
# # 什么是字符串
# # 就是以 单引号或者双引号引发来的任意文本
# # 'ancask的库时时刻刻'
# # "ABC事实就是惊声尖叫"
# # 建立字符串:
# str1="abcde骨灰盒fgaa"
# str2="abcde吾问无为谓fgaa"
# str3="abcdefg少时诵诗书所所aa"
# # 字符串运算
# 字符串链接
# str6="SKSDK就是死你KsbDSKDKSKK"
# str9="ASSASADADA1111"
# str=str6+str9
# print(str)
# 输出重复字符串
# str7="J数据的技术角度讲"
# str10=str7*3
# print(str10)
# 访问字符串中某一个字符 索引重零开始
# 字符串名[下标]
# 注意字符串不可变
# str="4555555555*5555SSSJSJSJ"
# print(str[1])
#截取字符串
# str5="ABCDEC"
# str6=str5[1:4] #从1截取到4可是不包含4
# print(str6) #BCD
# str5="ABCDEC"
# str6=str5[:4] 截取下标以前
# print(str6)#ABCD
# str5="ABCDEC"
# str6=str5[2:] #截取到末尾
# print(str6)#CDEC
#判断:
# str="HELLOW name"
# print("name" in str ) #True
# print("str5" not in str) #True
#将字符串str 当成有效的表达式来求返回计算结果
#eval(str) 功能 将字符串str 当成有效的表达式来求返回计算结果
num1=eval("123")
print(num1) #123
print( type(num1)) #<class 'int'>
print( eval("12+6")) #18
print( eval("12-6")) #6
print( eval("-126")) #-126
# len(srt) 返回字符串长度 就是字符个数
print( len("AAA"))
#lower() 将字符串里面的大写字母转换成小写
str6="abcFEG"
print(str6.lower()) #abcfeg
#upper() 将字符串里面的小写字母转换成大写
str9="abclktttttttttttggggggFEG"
print(str9.upper()) #ABCLKTTTTTTTTTTTGGGGGGFEG
print("AAAAAAAAAA".upper()) #AAAAAAAAAA
#swapcase() 将字符串里面大写字母转小写 小写转大写
str7="AI LOVER you header"
print(str7.swapcase()) #ai lover YOU HEADER
#capitalize() 首字母大写 其余小写
str0="i have you to"
print(str0.capitalize()) #I have you to
# title() 每一个单词的首字母大写
str2="have to nice"
print(str2.title()) #Have To Nice
# string.center(width)
# 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
#center(width,fillchar)
str77="wo ai nice lover"
print(str77.center(40,"*")) #************wo ai nice lover************
# string.ljust(width)
# 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
stra="wo ai nice lover"
print(stra.ljust(40,"%")) #wo ai nice lover%%%%%%%%%%%%%%%%%%%%%%%%
# string.zfill(width)
# 返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0
strb="wo ai nice lover"
print(strb.zfill(40)) #000000000000000000000000wo ai nice lover
# 返回字符串中str出现的次数 能够指定一个范围 默认从头至尾
# count(str[,start][,end])
str11="wo ai nice lover and lover to hao lover"
print(str11.count("lover")) #3
print(str11.count("lover",7,len(str11))) #3
#从左到右的 第一次出现的下标数 没有就返回-1
# string.find(str, beg=0, end=len(string))
# 检测 str 是否包含在 string 中，若是 beg 和 end 指定范围，
# 则检查是否包含在指定范围内，若是是返回开始的索引值，不然返回-1
str10="wo ai nice lover and lover to hao lover"
print(str10.find("lover")) #11
print(str10.find("ov")) #12
print(str10.find("lover",15,len(str10))) #21
# string.index(str, beg=0, end=len(string))
# 跟find()方法同样，只不过若是str不在 string中会报一个异常.
str18="aaaAAcBBBB"
print(str18.index("A"))#3
# string.lstrip()
# 截掉 string 左边的空格
# 默认是空格
str19=" wo ai nice lover and lover to hao lover"
print(str19.lstrip()) #wo ai nice lover and lover to hao lover
# string.rstrip()
# 截掉 string 右边的空格
# 默认是空格
str22=" wo ai nice lover and lover to hao lover "
print(str22.strip()) #wo ai nice lover and lover to hao lover
# string.strip([obj]) 去掉左右空格
# 在 string 上执行 lstrip()和 rstrip()
str28=" pppp ai nice lover and lover to hao lover "
print(str28.strip()) #pppp ai nice lover and lover to hao lover
# Python replace()
# old（旧字符串） 替换成 new(新字符串)，若是指定第三个参数max，则替换不超过 max
str3="this is string example....wow!!! this is really string";
print (str3.replace("is", "was")); #thwas was string example....wow!!! thwas was really string
print (str3.replace("is", "was", 3));#thwas was string example....wow!!! thwas is really string
# Python isnumeric() 方法检测字符串是否只由数字组成。这种方法是只针对unicode对象。
# 注：定义一个字符串为Unicode，只须要在字符串前添加 'u' 前缀便可，具体能够查看本章节例子。
# 若是字符串中只包含数字字符，则返回 True，不然返回 False
str55 = u"this2009";
print(str55.isnumeric()); #False
str11= u"23443434";
print (str11.isnumeric()); #True
# Python join() 方法用于将序列中的元素以指定的字符链接生成一个新的字符串
str = "-"
seq =("a", "b", "c")
print(str.join( seq )) #a-b-c
# 以什么分截取字符串 变成list列表
# split(str)
str55="AS-LOLSOLLS-ollll-kkk-LLLLL"
print(str55.split("-")) #['AS', 'LOLSOLLS', 'ollll', 'kkk', 'LLLLL']
str56="AS-LOLSOLLS-ollll-kkk-LLLLL-HHHHHHHHHH-000000000"
print(str56.split("-",3)) # ['AS', 'LOLSOLLS', 'ollll', 'kkk-LLLLL-HHHHHHHHHH-000000000']
# 看这个字符串里面有多少个单词
str57="AS-LOLSOLLS-ollll-kkk-LLLLL-HHHHHHHHHH-000000000"
aa=str57.split("-")
c=0
for x in aa:
if len(x)>0:
c+=1
print (c) # 7
# Python max() 方法返回字符串中最大的字母。
# Python min() 方法返回字符串中最小的字母。
str = "this-is-real-string-example....wow!!!";
print ("Min character: " + min(str))
# Min character: !
# 了解
# # Python maketrans() 方法用于建立字符映射的转换表，对于接受两个参数的最简单的调用方式，
# # 第一个参数是字符串，表示须要转换的字符，第二个参数也是字符串表示转换的目标。
# a = "aeiou"
# b = "12345"
# trantab = maketrans(a, b)
# str = "this is string example....wow!!!"
# print (str.translate(trantab))
# 在给定的范围内判断是否以给定的字符串开头 若是没有指定范围默认的整个字符串
str50="I have is dream"
print(str50.startswith("I")) # //True
# 在给定的范围内判断是否以给定的字符串结尾 若是没有指定范围默认的整个字符串
str51="I have is dream"
print(str51.endswith("dream")) #True
# isalpha()是判断字符串中至少有一个字符且全部的字符都是字母返回true 不然返回fales
str56="Ihaveisdream"
print(str56.isalpha()) # True
# isipper() 英文
# 若是字符串中至少有一个字符且全部的字符都是大写的英文字母返回 true 与false
print("SBC".isupper()) #True
print("SBb".isupper()) #False
print("SB123".isupper()) #True
print("Sa123".isupper()) #False
istitle() 方法检测字符串中全部的单词拼写首字母是否为大写，且其余字母为小写。
str = "This Is String Example...Wow!!!"
print (str.istitle()) #True
Python isspace() 方法检测字符串是否只由空白字符组成。
若是字符串中只包含空格，则返回 True，不然返回 False.
str = " "
print (str.isspace()) #True
实例
str="""9月6日，WePhone的创始人兼开发者苏享茂在Google+留
1下一份网帖称，前妻翟某某向他索要1000万人民币和一套房产。
2因为本身没有1000万又走投无路，将要所以离开人世，并在相册中留下
3与前妻的对话截图。9月9日，“北京时间”记者从苏享茂家眷处获悉，苏享茂于9
4月7日凌晨五点左右在公司附近的住所处跳楼自杀。苏享茂公布的遗书内容，尚没有获得翟某某回应。
59月6日，WePhone创始人兼开发者苏享茂用GoogleIDW
6nQiangXu发帖，称本身被恶毒前妻相逼，将要离开人世，WePhone
7之后将中止运营等信息，并附上前妻手机号码、工做单位。此外，苏享茂还在相册中上传本身与前妻的聊
8天截图，以及两人签署的离婚合约。网帖称，本身的前妻翟
9某某经过如下两点要挟本身：
0"""
aa=str.splitlines(True)
print(aa)
十五. 格式化输出
实例:
print("MY name is hellow jiab")
num=10
str="哈哈哈哈哈哈哈哈"
str2="17760453112"
#占位符 %d %f %s
#转义字符 \
print("num=%d，str=%s"%(num,str) )
十六. 布尔值和空值
# //布尔值就只有两种: True 和 false
b1=True
b2=false
print(b1,b2)
空值:是python中一个特殊的值 用None 来表示
None 不能理解
由于；零是有意义的
而None是一个特殊值
n=Noen
print(n Noen
十七. 列表(list)
# 列表 是一种有序的集合 来存储大量的数据
age1=32
# age2=22
# age3=45
# age4=42
# age5=49
# age6=450
# print((age1+age2+age3+age4+age5+age6)/5) #128
# 建立列表
# 格式: 列表名=[列表选项1,列表选项2,列表选项3,列表选项4,列表选项5]
# 建立一个空列表
# list1=[]
# 建立一个有元素的列表
# list2=[12,13,15,44]
# 注意: 列表中的元素数据 能够是不一样类型的数据
# list3=[1,2,3,"SHSHSHH","nice",True]
# print(list3)
# 列表元素的访问
# 取值: 格式 列表名[下标]
# 注意:访问不要越界
# list4=[1,2,3,5,6]
# print(list4[2]) #3
# 替换:
# list4=[2]=300
# print(list4) #1 2 300 6
# # 求列表中的平均值 list5=[22,23,24,25,66] index=0 sum=0 while index<5: sum+=list5[index] index+=1 if index==5: print(sum/5)
# 列表组合
# list6=[0,23,25,5]
# list7=[1,6]
# list8=list6+list7
# print(list8) #[0,23,25,5,1,6]
# 列表重复
# list9=[1,2,3]
# list10= list9*3
# print(list10) #[1,2,3,1,2,3,1,2,3]
# 判断元素是否在列表中
# list11=[1,2,3]
# print(3 in list11) #判断3在不在列表中 在返回 True
# # 列表截取
# list12=[4,5,6,7,8,9]
# print(list12[2:5]) # 6,7,8 截取2到5这个范围中
# print(list12[2:]) # 6 7 8 9 截取到最后
# print(list12[:5]) # 4 5 6 7 8 截取到下标5以前的下标
# # 二维列表
# list55=[[1,9,8],[2,3,4,6] ,[2,88,6,5]]
# #8
# print(list55[1][1]) #3
# print(list55[0][1]) #9
# print(list55[2][1]) #88
# # 列表方法
# # 该方法无返回值，可是会修改原来的列表
# # 在列表末尾添加新的对象 list.append(obj)追加一个元素到末尾
# aList = [123, 'xyz', 'zara', 'abc']
# List.append( 2009 )
# print ("Updated List : ", aList) #Updated List : [123, 'xyz', 'zara', 'abc', 2009]
# list5=[5,6,9]
# list5.append(6)
# list5.append([5,6])
# print(list5) #[5,6,9,6,[5,6]]
# 追加多个元素 在末尾一次性追加一个列表中多个值
# 该方法没有返回值，但会在已存在的列表中添加新的列表内容
# 如下实例展现了 extend()函数的使用方法：
# aList = [123, 'xyz', 'zara', 'abc', 123];
# bList = [2009, 'manni'];
# aList.extend(bList)
# print ("Extended List : ", aList ) #[123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']
# insert() 函数用于将指定对象插入列表的指定位置。
# index -- 对象 obj 须要插入的索引位置。
# obj -- 要插入列表中的对象。
# aList = [123, 'xyz', 'zara', 'abc']
# aList.insert( 3, 2009)
# print ("Final List : ", aList) #[123, 'xyz', 'zara', 2009, 'abc']
# pop() 函数用于移除列表中的一个元素（默认最后一个元素），而且返回该元素的值。
# obj -- 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。
# 该方法返回从列表中移除的元素对象。
# list1 = ['Google', 'Runoob', 'Taobao']
# list_pop=list1.pop(1)
# print ("删除的项为 :", list_pop)
# print ("列表如今为 : ", list1)
# 删除的项为 : Runoob
# 列表如今为 : ['Google', 'Taobao']
# remove() 函数用于移除列表中某个值的第一个匹配项
# obj -- 列表中要移除的对象。
# 该方法没有返回值可是会移除列表中的某个值的第一个匹配项。
# aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
# aList.remove('xyz');
# print ("List : ", aList) # [123, 'zara', 'abc', 'xyz']
# aList.remove('abc');
# print ("List : ", aList;) #[123, 'zara', 'xyz']
# 清楚列表中全部的数据
# list99=[56,78,94,2]
# list99.clear()
# print(list99) #[]
# 从列表中找出某个值得下标 第一个匹配的索引值
# list4=[2,3,4,6,3]
# list5=list4.index(3)
# print(list5) #1
# aList = [123, 'xyz', 'zara', 'abc'];
# print "Index for xyz : ", aList.index( 'xyz' ) ; # 1
# print "Index for zara : ", aList.index( 'zara' ) #2
# 列表中元素的个数
# list66=[2,5,46,78,8]
# print(len(list66)) #5
# reverse() 函数用于反向列表中元素。
# reverse()方法语法：
# 该方法没有返回值，可是会对列表的元素进行反向排序。
# aList = [123, 'xyz', 'zara', 'abc', 'xyz']
# aList.reverse()
# print ("List : ", aList) # ['xyz', 'abc', 'zara', 'xyz', 123]
# 获取列表中最小的值
# list22=[78,9,4,5]
# print(min(list22)) #4
# 返回元素在列表中出现的次数
# count() 方法用于统计某个元素在列表中出现的次数。、
# 查看一个元素在列表中出现了多少次
# cont()
# list8=[1,2,3,45,2,9,66,2,8,2]
# print(list8.count(2)) #4
# 删除列表中屡次出现的元素 # list66=[5,56,89,6,5,36,5,6,5] # all=list66.count(5) #4 # Index=0 # while Index<all： # list66.remove(5) # index+=1 # print (list66)
# sort() 函数用于对原列表进行排序，若是指定参数，则使用比较函数指定的比较函数。
# sort()方法语法：
# list.sort(cmp=None, key=None, reverse=False)
# cmp -- 可选参数, 若是指定了该参数会使用该参数的方法进行排序。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# 将元组转换成列表
a=list((1,2,3,4))
print (a) # [1, 2, 3, 4]
# 拷贝(浅拷贝)
list2=[12,3,45,66]
list3=list2
list3[1]=200
print(list3) # [12, 200, 45, 66]
print(list2) #[12, 200, 45, 66]
print(id(list3)) # 6355144
print(id(list2)) # 6355144
# 深拷贝 内存拷贝
list30=[1,2,3,4,5]
list31=list30.copy()
list30[1]=200
print(list30) # [1, 200, 3, 4, 5]
print(list31) # [1, 2, 3, 4, 5]
print(id(list30)) # 39035784
print(id(list31)) # 39383944
# 输出10个数字找出第二大值 # listNum=[] # num=0 # while num <5: # val=int(input("请输入5个数:")) # listNum.append(val) # num+=1 # print (listNum) # # 升序排列 # listNum.sort() # print (listNum) # count=listNum.count(listNum[len(listNum)-1]) # c=0 # while c<count: # listNum.pop() # c+=1 # print(listNum[len(listNum)-1]) # 请输入5个数:65 # 请输入5个数:55 # 请输入5个数:32 # 请输入5个数:88 # 请输入5个数:57 # [65, 55, 32, 88, 57] # [32, 55, 57, 65, 88] # 65 #90=2*3*3*5 num=int(input("输入一个是因式分解")) i=2 while num!=1: if num%i==0: num//=i print("i=",i) print("num=",num) else: i+=1
十八. 绘图模块
# 导入绘图模块
# import turtle
# turtle.forward
十九. 元组
# Python的元组与列表相似，不一样之处在于元组的元素不能修改。
# 元组使用小括号，列表使用方括号。
# 元组建立很简单，只须要在括号中添加元素，并使用逗号隔开便可。
# 建立空元组
# tup1 = ();
# 元组中只包含一个元素时，须要在元素后面添加逗号
# tup1 = (50,);
# 元组可使用下标索引来访问元组中的值
# 格式:元组名:下标
tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );
print (tup1[0]) #physics
print (tup2[1:5]) #(2, 3, 4, 5)
print (tup2[-1]) #7 元组获取最后一个元素-1 倒数是从-1开始
# 元组不能变 是指元组里面的元素不能够改变
# 元组中的元素值是不容许修改的，但咱们能够对元组进行链接组合，以下实例:
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
# 建立一个新的元组
tup3 = tup1 + tup2;
print (tup3); #(12, 34.56, 'abc', 'xyz')
# tup6=(1,2,3,[7,8,9])
# tup6[-1][1]=1000
# print(tup6) # (1, 2, 3, [7, 1000, 9])
# 元组中的元素值是不容许删除的，但咱们可使用del语句来删除整个元组
# tup6=(1,2,3,[7,8,9])
# del tup6
# 元组链接
t1=(1,2,3)
t2=(10,25,39)
t3=t1+t2
print(t3) # (1, 2, 3, 10, 25, 39)
# 元组重复
# t1=(1,2,3)
# print(t1*3) #(1, 2, 3, 1, 2, 3, 1, 2, 3)
# # 判断元素是否在元组里
# t5=(1,2,3,20)
# print(20 in t5) #True
# 元组截取
# 格式 :
# 元组名:[开始下标:结束下标]
# 从开始下标 到结束下标以前
# t9 = ('physics', 'chemistry', 1997, 2000);
# tup8 = (1, 2, 3, 4, 5, 6, 7 );
# print (tup9[0]) #physics
# print (tup8[1:5]) #(2, 3, 4, 5)
# 二维元组 :就是元素为一维元组的的元组
t0=((1,2,3),(4,5,6),(7,8,9))
print(t0[1][1]) #5
# 元组的方法
# Python 元组 len() 函数计算元组元素个数。
# tuple2 = (123, 'xyz', 'zara')
# aa=len(tuple2)
# print(aa) #3
# Python 元组 max() 函数返回元组中元素最大值。
ta=(123, 'xyz', 'zara', 'abc')
print(max(ta)) #zara
# Python 元组 tuple() 函数将列表转换为元组。
aList = [123, 'xyz', 'zara', 'abc'];
aTuple = tuple(aList)
print (aTuple) #(123, 'xyz', 'zara', 'abc')
# 元组的遍历
for x in (1,2,3,4,5,6):
print(x) #123456
二十. 字典
# 字典是另外一种可变容器模型，且可存储任意类型对象。
# 字典的每一个键值(key=>value)对用冒号(:)
# 分割，每一个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式以下所示
# 键必须是惟一的，但值则没必要。
# 值能够取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
# 字典存储数据是无序的存储
# 一个简单的字典实例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
# 也可如此建立字典：
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
# 元素的访问
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dict["Name"]) #Runoob 没有就会报错
print(dict.get("Name")) #Runoob 若是字典有就获取到这个元素 没有也不会报错
# 添加
dict1= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict1["age"]=22
print(dict1) #{'age': 22, 'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 修改
dict2= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict2["Class"]=10000
print(dict2) # {'Class': 10000, 'Name': 'Runoob', 'Age': 7}
# 删除字典元素
# 能删单一的元素也能清空字典，清空只需一项操做。
# 显示删除一个字典用del命令，以下实例：
dict3 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典
# 字典遍历 dict6= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} for key in dict6: print(key) # Class # Age # Name
dict4= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
for key in dict4:
print(key,dict4[key])
# Age 7
# Class First
# Name Runoob
dict7= {'Name': 'Runoob', 'Age': 22, 'Class': 'First'}
for value in dict7.values():
print(value)
# 22
# Runoob
# First
dict8= {'Name': 'Runooeeeeeb', 'Age': 22, 'Class': '哈哈哈哈哈'}
for k,v in dict8.items():
print(k,v)
# Name Runooeeeeeb
# Age 22
# Class 哈哈哈哈哈
# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
# 同时列出数据和数据下标，通常用在 for 循环当中。
# enumerate(sequence, [start=0])
# 参数
# sequence -- 一个序列、迭代器或其余支持迭代对象。
# start -- 下标起始位置。
dict10= {'Name': 'RAAAAAA', 'Age': 220000, 'Class': '哈哈哈哈AAAA哈'}
for k,v in enumerate(dict10):
print(k,v)
# 0 Age
# 1 Class
# 2 Name
字典和list列表比较
字典 :查找和插入的速度极快 不会随着key value 增长而加慢
须要占用大量的内存
list
查找和插入的速度随着数据的增多而 速度会减慢
占用空间小 浪费的内存少
# 字典是另外一种可变容器模型，且可存储任意类型对象。
# 字典的每一个键值(key=>value)对用冒号(:)
# 分割，每一个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式以下所示
# 键必须是惟一的，但值则没必要。
# 值能够取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
# 字典存储数据是无序的存储
# 一个简单的字典实例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
# 也可如此建立字典： dict1 = { 'abc': 456 }; dict2 = { 'abc': 123, 98.6: 37 };
# 元素的访问
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dict["Name"]) #Runoob 没有就会报错
print(dict.get("Name")) #Runoob 若是字典有就获取到这个元素 没有也不会报错
# 添加
dict1= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} dict1["age"]=22 print(dict1) #{'age': 22, 'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
# 修改
dict2= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict2["Class"]=10000
print(dict2) # {'Class': 10000, 'Name': 'Runoob', 'Age': 7}
# 删除字典元素
# 能删单一的元素也能清空字典，清空只需一项操做。
# 显示删除一个字典用del命令，以下实例：
dict3 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除键 'Name'
dict.clear() # 清空字典
del dict # 删除字典
# 字典遍历
dict6= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
for key in dict6:
print(key)
# Class
# Age
# Name
dict4= {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
for key in dict4:
print(key,dict4[key])
# Age 7
# Class First
# Name Runoob
dict7= {'Name': 'Runoob', 'Age': 22, 'Class': 'First'}
for value in dict7.values():
print(value)
# 22
# Runoob
# First
dict8= {'Name': 'Runooeeeeeb', 'Age': 22, 'Class': '哈哈哈哈哈'}
for k,v in dict8.items():
print(k,v)
# Name Runooeeeeeb
# Age 22
# Class 哈哈哈哈哈
# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，
# 同时列出数据和数据下标，通常用在 for 循环当中。
# enumerate(sequence, [start=0])
# 参数
# sequence -- 一个序列、迭代器或其余支持迭代对象。
# start -- 下标起始位置。
dict10= {'Name': 'RAAAAAA', 'Age': 220000, 'Class': '哈哈哈哈AAAA哈'}
for k,v in enumerate(dict10):
print(k,v)
# 0 Age
# 1 Class
# 2 Name
字典和list列表比较
字典 :查找和插入的速度极快 不会随着key value 增长而加慢
须要占用大量的内存
list
查找和插入的速度随着数据的增多而 速度会减慢
占用空间小 浪费的内存少
案例1 : 做业讲解歌词下一秒
dict={} #空字典
# Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行做为元素的列表，
# 若是参数 keepends 为 False，不包含换行符，若是为 True，则保留换行符。
aa=str.splitlines()
# print(aa) # 1
for bb in aa: #循环每一行
# print(bb) #2
cc=bb.split("]")
# print(cc)
# print(cc[0])
# print(len(cc))
for i in range(len(cc)-1):
# print(i)
dd=cc[i][1:]
# print(dd)
timelist=dd.split(":")
time=float(timelist[0])*60+float(timelist[1])
dict[time]=cc[-1]
print(dict)
案例2 : 做业时间一秒 :
# 时间下一秒 # 千锋教育 [函数基础01] # 12：23:23 timeStr=input("请输入时分秒:") timelist=timeStr.split(":") h=int(timelist[0]) m=int(timelist[1]) s=int(timelist[2]) s+=1 if s==60: m+=1 s=0 if m==60: h+=1 m=0 if h==24: h=0 print(h,m,s)
str="[02:05.32][03:05.45][04:54.56]" str2=str.split("]") # ['[02:05.32', '[03:05.45', '[04:54.56', ''] # # # # [02:05.32 # [03:05.45 # [04:54.56 for index in str2: print(index[1:]) # 02:05.32 # 03:05.45 # 04:54.56 aa={} bb="KSKKSK" cc="卡卡卡卡" aa[bb]=cc print(aa) # {'KSKKSK': '卡卡卡卡'}
二十一. set集合
# set() 相似字典(dict) 是一组key 集合 不存储
# 本质: 无序 和 无重复的元素的集合
# 建立:
# 建立set 须要 一个列表(list)或者元组(tuple)或者字典(dict)做为输入的集合
# 重复元素能够在set中自动过滤
s1=set([1,2,3,4,5,6,7])
print(s1) #{1, 2, 3, 4, 5, 6, 7}
# 重复元素能够在set中自动过滤
s2=set([1,2,3,4,1,2,3])
print(s2) #{1, 2, 3, 4}
s3=set((10,22,33,4,10,22,33))
print(s3) #{33, 10, 4, 22}
# set() 相似字典(dict) 是一组key 集合 不存储
s4=set({"name":"小明","age":25,"study":"python"})
print(s4) #{'study', 'age', 'name'}
# set添加 add
s5=set([1,2,3])
s5.add(1000)
print(s5) #{1000, 1, 2, 3}
s5.add(3) #能够添加剧复的元素 可是不会有效果
# s5.add([7,8,9]) # set 的元素不能是列表 由于列表是可变的
s5.add((7,9,6))
print(s5) # {1000, 1, 2, 3, (7, 9, 6)} 由于元组不可变全部能添加进去
# s5.add({"name":"张三"})
# print(s5) #set的元素不能是字典 由于字典是可变的
# 添加更新update
# update 插入添加整个 list tuple 字符串打乱了
s6=set([1,2,3])
s6.update([6,7,9])
print(s6) #{1, 2, 3, 6, 7, 9} 字符串打碎查入了
s7=set([1,2,3])
s7.update((45,46,47))
print(s7) #1, 2, 3, 45, 46, 47}
s8=set([1,2,3])
s8.update(("name"))
print(s8) #{1, 2, 3, 'a', 'e', 'n', 'm'}
# 删除
s9=set([1,2,3])
s9.remove(2)
print(s9) #{1, 3}
# set是没有索引的
# 循环遍历
s10=set([1,2,3,4,5,6]) for i in s10: print(i) #1 2 3 4 5 6
s11=set("name") for i in s11: print(i) #n a m e
# set里面有交集和并集
# 交集 &
str12=set([1,2,3,4,5]) str13=set([11,2,3,44,55]) a1=str12&str13 print(a1) #{2, 3} print(type(a1)) #<class 'set'>
# 并集 |
str12=set([1,2,3,4,5]) str13=set([10,2,3,6]) a2=str12|str13 print(a2) #{1, 2, 3, 4, 5, 6, 10} print(type(a2)) #<class 'set'>
数据转换
# list ----set a1=[1,2,3,4,5,6] a2=set(a1) print(a2) #{1, 2, 3, 4, 5, 6} # tuple----set a3=(1,2,3000,4,5,600000) a4=set(a3) print(a4) #{600000, 1, 2, 4, 5, 3000} # set----list a5={1000,200,3000,400,500,} a6=list(a5) print(a6) #[400, 3000, 200, 1000, 500] #set-----tuple a7={9999,11,1000,400,20000,} a8=tuple(a7) print(a8) #(20000, 400, 1000, 11, 9999)
二十二. os 模块
# 导入模块
import os
# 获取操做系统类型 nt--->windows
#max os x #苹果操作系统
# print(os.name) # nt 表明是window模块
# # 打印操做系统详细信息(目前只有在liux系统和mac系统上打印)
#print(os.uanme) # windows不支持
# 获取操做系统中的环境变量
print(os.environ)
# 获取指定环境变量
print(os.environ.get("PROGRAMFILES"))
# 获取当前目录 ./
print(os.curdir) # .
# 获取当前工做目录 即当前python 脚本所在的目录
print(os.getcwd()) #E:\Studypython\py2
# 返回指定目录下的全部文件 以列表的形势 包含文件目录
print(os.listdir(r"E:\Studypython\py2\1"))#['01.txt', '02.txt', '03.txt', '04.txt', '05.txt']
# 建立文件目录
# os.mkdir("Study")
# 删除目录
# os.rmdir("Study")
# 建立绝对目录
# os.mkdir(r"E:\Studypython\py2\2\HHH")
# 获取文件属性
# print(os.stat("Study"))
# os.stat_result(st_mode=16895, st_ino=16888498602707557, st_dev=806918758,
# st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1527945156,
# st_mtime=1527945156, st_ctime=1527945156)
# 重命名
# os.rename("Study","HHH")
# 删除普通文件
# os.remove("HHH\1.txt")
# 运行shell命令
# os.system("notepad")
# os.system("write")
# 有些方法存在os模块里 还有些存在于os.path
# 查看当前的绝对路径
# prin(os.path.abspath("./HHH"))
# 拼接路径
# 注意参数二开始不能有斜杠
p1=r"E:\Studypython\py2\HHH"
p2="name11"
print(os.path.join(p1,p2)) #E:\Studypython\py2\HHH\name11
# 拆分路径
path2=r"E:\Studypython\py2\HHH"
print(os.path.split(path2)) #('E:\\Studypython\\py2', 'HHH')拆分就变成元组了
# 获取扩展名
path3="D:\tx\QQLive\Log\QXMatrix_dll_14-35-26_7300.log"
print(os.path.splitext(path3))
# ('D:\tx\\QQLive\\Log\\QXMatrix_dll_14-35-26_7300', '.log')
# 判断是否为目录
print(os.path.isdir(path3)) #False
# 判断文件是否存在
print(os.path.isfile("HHH")) #False
# 判断目录是否存在
path6= r"F:\dbnodeloginmd5"
print(os.path.exists(path6)) # True
# 获取文件大小
path9= r"F:\dbnodeloginmd5\login.js"
print(os.path.getsize(path9)) #1717字符
# 获取文件目录
path10= r"F:\dbnodeloginmd5\login.js"
print(os.path.dirname(path10)) # F:\dbnodeloginmd5
# 获取文件名
print(os.path.basename(path10)) #login.js
返回指定路径下的文件和文件夹列表os.listdir(path)
- 1. Python基础(二)
- 2. python基础二
- 3. python(二)基础
- 4. python基础（二）
- 5. Python基础（二）
- 6. Python 基础二
- 7. Python--基础二
- 8. python 基础二
- 9. Python基础篇（二）
- 10. python基础篇（二）
- 更多相关文章...
- • Kotlin 基础语法 - Kotlin 教程
- • Scala 基础语法 - Scala教程
- • Kotlin学习（二）基本类型
- • RxJava操作符（二）Transforming Observables
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. CVPR 2020 论文大盘点-光流篇
- 2. Photoshop教程_ps中怎么载入图案？PS图案如何导入？
- 3. org.pentaho.di.core.exception.KettleDatabaseException:Error occurred while trying to connect to the
- 4. SonarQube Scanner execution execution Error --- Failed to upload report - 500: An error has occurred
- 5. idea 导入源码包
- 6. python学习 day2——基础学习
- 7. 3D将是页游市场新赛道？
- 8. osg--交互
- 9. OSG-交互
- 10. Idea、spring boot 图片(pgn显示、jpg不显示)解决方案
- 1. Python基础(二)
- 2. python基础二
- 3. python(二)基础
- 4. python基础（二）
- 5. Python基础（二）
- 6. Python 基础二
- 7. Python--基础二
- 8. python 基础二
- 9. Python基础篇（二）
- 10. python基础篇（二）