零基础Python(一)

先贴一些入门的代码:

import random
secret=random.randint(1,10)
print("**************恕瑞玛,你们的皇帝回来啦!****************")
temp=input("Hei,guy,Guess what number is my favorite...:")
guess = int(temp)
while guess != secret:
    temp=input("You guess wrong...Try again!:")
    guess=int(temp)
    if guess==secret:
        print("You guess right")
        print("But No Ruan Yong")
    else:
        if guess > secret:
            print("That's big!")
        else :
            print("That's small!")
print("Good Game")   
print("*************Demo***********")
temp=input("Please input the grade to class:")
grade=int(temp)
if grade > 90:
    print("Your grade is A...")
else :
    if grade >= 80 and grade < 90:
        print("Your grade is B...")
    else :
        if grade >= 60 and grade < 80:
            print("Your grade is C...")
        else :
            if grade < 60 :
                print("You should hava some B number in your heart...")
print("Game Over...")    

print("************3-2DemoEx*********")
temp=input("Please input you number:")
grade=int(temp)
if grade > 90:
    print("Your grade is A...")
elif grade >= 80 and grade < 90:
    print("Your grade is B...")
elif grade >= 60 and grade < 80:
    print("Your grade is C...:")
else :
    print("B number ,You know")      

这里需要针对上面代码进行一些说明:
1.python3的输出语句为:print(“内容…”)
2.python没有变量类型这一说,诸如java的String、int、boolean等等。
3.input()函数,就是等待用户输入,括号内是输入前的提示语句。
4.python有两个初学者必须知道的函数,分别为dir()help(),通过这两个方法,我们可以查看概念相关的内置函数,也就是BIF;
dir()函数获得对象中可用属性的列表
help()函数帮助我们了解模块、类型、对象、方法、属性的详细信息

此外,
1.break、continue这俩Python也有;
2. * *//,第一个是幂运算,比如2**3==8,第二个是地板除,所得除数定为整数。
3. python中,可以用字符串*整数,相当于复制了N份。ex:

>>> str1='hello'
>>> str2=str1*3
>>> str2
'hellohellohello'
  1. 上面后面两段代码是为了了解elif这个关键字
    可以包含任意个elif语句。if-elif-else结构只会执行一个代码块,如果想运行多个代码块,可以使用一系列独立的if语句。

  2. python中可以用import builtins (或直接使用__builtins__)查看内置函数,内置函数中,以字母形式的都可以用help(函数名),来查看具体信息。

  3. python的foreach语句:
    for 元素(随便起个名)in (字符串、列表什么的)
    print(元素)
    ex: for each in ‘Crazy’
    print(each)
    7.python的灵魂在于TAB键,相当于JAVA中的大括号了。

  4. python三目运算符:
     条件为真时的结果 if 判段的条件 else 条件为假时的结果

列表(list)

首先明确一点,列表是用中括号的----->[]
python中没有数组,只有列表(list)和元组(tuple),所以,列表自然而言的充当起了数组的角色,列表除了可以存放单一类型的数据,还可以存储不同类型的数据。
member=['天行九歌','秦时明月','空山鸟语']—>单一类型
member=['天行九歌',2,'空山鸟语',3.14,[1,'Time',2.12]]—>复杂类型
member=[]—>空列表
输出一下:

for each in member :
	print(each) 

有关列表的一些操作:

1.向列表中添加元素

append():—>一次只能添加一个元素,加多个会报错的。这个是在列表末尾添加元素。
ex:member.append('虫师')
如果想一次加多个元素,可以使用:
extend():
member.extend([''没有黄段子的无聊世界,'命运石之门']),实际上
extend()也只能接收一个元素,这个元素是个列表,列表里可以存放多个元素。
insert():
append()、extend()都是把元素添加到列表末尾。而insert()则不同:
insert(int pos,object item), 第一个是插入的位置,第二个是插入的元素

member.insert(1,['Ok','No'])

2.在列表中删除元素

member[pos]取数据元素也是这种操作,嗯,跟java,c一样。
①remove()
remove(元素值),比如上面的remove(‘天行九歌’),这个只能删除一个,多个的话,需要遍历删除了。
②del(是一个语句,不是方法,所以不用括号),ex:

del member[1]

del member—>会删除掉整个列表
③pop()【列表毕竟是个栈嘛,有这个也不为怪】
从列表中取出最后一个元素,返回出来,这样列表中也就没了。
member.pop()
4.列表分片(Slice)
利用分片,可以一次性取多个元素。分片也很简单,记住,前闭后开,如下:
member[1:3]--------->前闭后开,会取出pos为1,2的两个元素
member[ :3]---------->会取出pos为0,1,2的三个元素
member[1: ]---------->为取出pos为1以及之后的元素
member[]-------------->会取出真个列表的元素
可以通过分片赋值给其他列表,然后进行相关的操作。注意,别越界了!!
正如之前负数可以指代最后几个元素,切片也可以使用负数分片用来从列表后面取数据。
比如,取列表的最后三个元素:

b=[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> c=b[-3:]
>>> c
[15, 17, 19]

5.比较操作符、逻辑操作符、连接操作符、重复操作符、成员关系操作符
list可以比较大小,ex:
list[123]>list[456] ===>False
list[123,456]>list[234,324]---->False,
如果有多个元素,就会只比较第一个元素;
如果是字符串,那么就根据ASCII码来比较
list也可以相加,ex:
list1=[123]
list2=[456]
list3=list1+list2
list3-----》[123,456]
Tip:尽量不要这么加,用append、extend方法才是规范用法;list只能加list,不能加其他类型的变量。
③list可以进行乘法操作

list1*3---->[123,123,123]

④in、not in操作符
用来判断元素在不在列表中;

456 in list1---->False

123 not in list1---->False

Tips:in 、not in只能判断一层,内嵌的list中的元素是察觉不到的,ex:
list4=[123,[‘天马行空’,‘万里奔腾’],456]
‘天马行空’ in list4-------------->False
‘天马行空’ in list4[1]----------->True
list[1][1]------------------------->万里奔腾
dir(list)------->查看list的BIF
列一下吧:
append、clear、copy、count、extend、index、insert、
pop、remove、reverse、sort
ex:
list4.count(123)------------>会返回list4中123出现的次数
list4.index(123)------------>会返回list4中123的索引值,第一次出现的索引值
list4.index(123,3,7)-------->返回list4中索引3到7之间123的索引值
list4.reverse()-------------------->成员顺序反转【前后颠倒】
list4.sort()------------------------->成员排序,从小到大

>>> ss=[1,'abc','zzg',2]
>>> ss.sort()
Traceback (most recent call last):
  File "", line 1, in 
    ss.sort()
TypeError: '<' not supported between instances of 'str' and 'int'

如果列表中有不同类型的item,那么比较会报错的,要同等类型比较。
而且用sort()函数进行排序后,列表的顺序就不会再回到原来的排序了。如果想保留原来的排序,只是临时拍一下序,就用sorted()函数就可以。

如果想从大到小:
list4.sort(reverse=True),即可反转
这里需要注意的是,切片和直接赋值的区别:
list2=list1[:]
list3=list1,
list2和list3赋值之后虽然都一样,但是如果对list1进行排序
那么list3排序也会跟着改变。这就很尴尬了。所以赋值最好用切片,
保持原则才是最好的。
Tips:能用BIF解决的事情,就不要用算数运算符操作。很容易导致问题的出现
5.避免索引错误
有时候为了防止列表越界报错,比如只有三个元素,你们下标为4的元素,肯定数组越界,python中,为了取最后一个元素,可以采用listName[-1]这种操作,用-1指代最后一位元素。-2是倒数第二个,以此类推
6.生成数值列表可以使用range()函数:

>>> for i in range(1,10):
print(i)

1
2
3
4
5
6
7
8
9

也可以将之转换为列表:list(range(1,10))


元组

元组和列表类似,很多列表的操作,元组也可以,像分片等,但也有区别:
1.元组是用圆括号
2.元组是不能被修改!【但有方法在一个元组上修改得到一个新的元组,看似是修改,实则不然,跟str一样】

>>> d=('zzg','SprrowZ','RyeCatcher')
>>> d[-1:]
('RyeCatcher',)
>>> d[0]='xg'
Traceback (most recent call last):
  File "", line 1, in 
    d[0]='xg'
TypeError: 'tuple' object does not support item assignment

如果想直接修改,只会收到报错信息~
3.temp=(1)===> 创建的是int,如果想创建只有一个元素的元组:
temp=(1,)----->加一个逗号,这个逗号很关键的,空元组直接用小括号即可
4.8*(8,)---->(8,8,8,8,8,8,8,8)
5.元组其实也可以新增和删除,不过需要换一下思路:
新增:把元素分割成两部分,中间加上新增的元组即可:

temp=temp[:2]+('何处是鬼畜',)+temp[2:]

删除:
完全删除:del temp 实际上没啥实际用处


字符串—>各式各样的内置函数

1.字符串分割:

 str='where is my dream'
temp=str[:8]
====>temp='where is'

可见这个分片字符串也可以分割的。

2.字符串的插入跟tuple基本一致:

str=str[:8]+'heart'+str[8:]====>str='where isheart my dream'

3.capitalize()----->把字符串的第一个字符改为大写
casefold()------->把整个字符串的所有字符改为小写
center(width)—>将字符串居中,并使用空格填充至长度width的新字符串
count(sub[,start[,end]])—>返回sub在字符串里边出现的次数,start和end参数表示范围,可选
encode(encode=‘utf-8’,errors=‘strict’)---->以encoding指定的编码格式对字符串进行编码
endswith(sub[,start[,end]])---->检查字符串是否以sub字符串结尾,如果是返回True,否则返回False,start和end参数表示范围,可选
expandtabs([tabsize=8])---->把字符串中的tab(\t)符号转换为空格,如不指定参数,默认的空格数量是tabsize=8个,这个8是包含前面字符的
find(sub[,start[,end]])----->检测sub是否包含在字符串中,如果有则返回索引值,否则返回-1,start和end参数表示范围,可选
index(sub[,start[,end]])---->跟find方法一样,不过如果sub不在string中会产生一个异常
isalnum()---->如果字符串至少有一个字符并且所有自负都是字母或数字,则返回T入额,否则返回false
isalpha()---->如果字符串至少有一个字符并且所有字符都是字母则返回True,否则返回False
isdigit()------>如果字符串值只包含数字则返回True,否则返回False
islower()----->如果字符串至少包含一个区分大小写的字符,并且这些字符都是小写,则返回True,否则返回False
isnumberic()----->如果字符串只包含数字字符,则返回True,否则返回False
isspace()----->如果字符串只包含空格,则返回True,否则返回False
istitle()------->如果字符串是标题化(所有的单词都是以大写开始,其余字母都是小写)则返回True,否则返回False
isupper()----->如果字符串中至少包含一个区分大小写的字符,并且这些字符都是大写,则返回True,否则返回False
join(sub)----->以字符串作为分割符,插入到sub中所有的字符之间
ljust(width)---->和上面的center对应,返回一个左对齐的字符串,并使用空格填充至长度为width的新字符串
lower()----->转化字符串中所有大写字符为小写
lstrip()------>去掉字符串左边的所有空格
partition(sub)---->找到字符串sub,把字符串分成一个三元组,如果字符串中不包括sub则返回(‘原字符串’,’’,’’)
replace(old,new[,count])—>把字符串中的old字符串替换为new子字符串,如果count指定,则替换不超过count次
rfind(sub[,start[,end]]----->类似于find(),不过是从右边查找
rindex(sub[,start[,end]])---->类似于index()方法,不过是从右边开始查找
rpartition(sub)…
rstrip()-------->删除字符串末尾的空格
split(sep=None,maxsplit=-1)------>不带参数默认是以空格作为分隔符切片字符串,如果maxsplit参数有设置,则仅分割maxsplit个字符串,返回切片后的子字符串拼接的列表
splitlines([keepends])…
startswith(prefix[,start[,end]])----->检查字符串是否以prefix开头,是则返回True,否则返回False,start和end参数可以指定范围检查,可选。
strip([chars])----->删除字符串前边和后边所有的空格,cahrs参数可以定制删除的字符,可选。
swapcase()-------->翻转字符串中的大小写
title()------>返回标题化的字符串
translate(table)------>根据table的规则(可以由str.maketrans(‘a’,‘b’)定制)转换字符中的字符
upper()------>转换字符串中的所有小写字符为大写
zfill(width)---->返回长度为width的字符串,原字符串右对齐,前边用0填充


字符串格式化:
格式化输出嘛,你懂得,无非套个模板,输入自己的变量,对应java中的String.format(),不过貌似python的格式化输出更强一些,python的字符串格式化有三种方法:
1.位置映射:
“{}:{}”.format(‘i love you’,‘forever’)
ex:

 'Who i {0}is {1}'.format('love','you')
 ----->'Who i loveis you'

2.关键字映射:
“{server}{0}:{1}”.format(‘this is’,‘china’,server=‘mobile’)
ex:

 'The {param} you {0} is {1}'.format('leave','2018',param='time')
 -------->'The time you leave is 2018'

这里需要注意一点,在format函数中,位置参数必须在关键字参数之前,否则会报错的!
这里提一下转义字符:
\\–>打印出来就是一个反斜杠
\t–>打印出来就会看到前面空了一个TAB的位置
必须调用print()函数才会有效果。
这里如果我们想打印出来大括号,则可以在外面再套一层大括号,ex:

 '{{0}}'.format('随便填')
 ----->'{0}'

3.格式符
格式化为真实值预留位置,并控制显示的格式。格式符可以包含一个类型码,用以控制显示的类型,类型码如下:
%c 单个字符
%s 字符串(采用str()的显示)
%r 字符串(采用repr()的显示)
%b 二进制整数
%d 十进制整数
%o 八进制整数
%x 十六进制整数
%e 指数(基底写为e)
%E 指数(基底写为E)
%f 浮点数
%F 浮点数,与上面的相同
%g 指数或浮点数
%G 指数或浮点数
%% 字符‘%’
字符串通过tuple,也就是元组传入实际的值
ex:

'%d +%d=%d' % (1,1,3)
'%o' % 10---->'12'
'%e' % 27.658--->'2.765800e+01'
'%d%%' % 24---->'24%'
'%5.1f' % 251.1234--->'251.1'

字符串的一些相关操作:
1.在字符串中分行,输入\n即可:

>>> print('time\n is\n possiable')
time
 is
 possiable
>>> 

2.如果想去除字符串右边的空格符,可以用rstrip()方法:

>>> a='python  '
>>> print(a)
python  
>>> b='python     '
>>> a==b
False
>>> a.rstrip()==b.rstrip()
True

同理,如果想去掉左边的可以用lstrip(),两边都去掉的话用strip()
3.



序列

序列是一种统一的说法,序列包含列表(list)、元组(tuple)、字符串(str)
列表、元组和字符串的共同点:
①都可以通过索引得到每一个元素
②默认索引值总是从0开始
③可以通过分片的方法得到一个范围内的元素的集合
④有很多共同的操作符(重复操作符、拼接操作符、成员关系操作符)

list():把一个可迭代对象转换为列表。【可以不带参,也可以带一个迭代器的参数】
tuple([iterable]):把一个可迭代对象转换为元组。
迭代:所谓迭代就是重复反馈过程的活动。
ex:

b='Expectation is the root of all heartache.'
b=list(b)
b---->
['E', 'x', 'p', 'e', 'c', 't', 'a', 't', 'i', 'o', 'n', ' ', 'i', 's', ' ', 't', 'h', 'e', ' ', 'r', 'o', 'o', 't', ' ', 'o', 'f', ' ', 'a', 'l', 'l', ' ', 'h', 'e', 'a', 'r', 't', 'a', 'c', 'h', 'e', '.']

c=(1,1,2,3,4,5,5,5)
c=list(c)
c--------->[1, 1, 2, 3, 4, 5, 5, 5]

in关键字
可以通过in来判断元素是否在序列中,当然序列包括列表、元组和字符串,in是适用于这三者:

>>> b=[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
>>> d=('zzg','SprrowZ','RyeCatcher')
>>> cc='dnf'


>>> 'zzg'in d
True
>>> cc='dnf'
>>> 'd'in cc
True
>>> 1 in b
True

如果是不包含,用not in用法一样。
几个函数:
【需要注意一点,用底下几个函数的时候,序列中不要char和int混用,会报错】
1.len(),取list的长度,里面传入的参数必须得是定义过的,不然会报错
2.max(),返回序列或者参数集合中的最大值,因为是序列,所以里面传str、tuple或者list都可以
4.min(),如上,取最小值
5.sum(),求和,要求同上
6.sorted(),序列排序,与list.sort()效果是一样的,默认从小到大
7.reversed(),返回迭代器列表,可以在外面包裹一层list()查看
8.enumerate(),返回带有index的元素,很骚
9.zip(),zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,返回的是一个对象。如需展示列表,需手动 list() 转换。
ex:


    max(1,2,3,4,5)--->5

max(b)[上面的列表]---->'x'[根据ASCII码比较大小]

    max((1,2,3))------->3

如果是:


    min((1,2,3,4,5,'a'))

就会报错,int不能跟ASCII码直接比较。

sorted()、reversed()

a=[23,34,54,64,234,325,234]
sorted(a)
----》[23, 34, 54, 64, 234, 234, 325]
 reversed(a)
 -----》[迭代器对象]
 list(reversed(a))
 ------》[234, 325, 234, 64, 54, 34, 23]********貌似是个bug?待查+1

enmurate()

list(enumerate(a))
--->[(0, 23), (1, 34), (2, 54), (3, 64), (4, 234), (5, 325), (6, 234)]

zip()

a=[1,2,3,4,5,6,7,8]
b=[4,5,6,7]
list(zip(a,b))
------>[(1, 4), (2, 5), (3, 6), (4, 7)]

ifelse语句
java中与、或是&&、|| ,而python则不同,与、或为andor

你可能感兴趣的:(python)