python学习笔记(8):

一、变量和类型

1.Python基本变量类型: 整数 ,浮点数 ,字符串, 布尔值 ,空值 ,函数, 模块, 类型, 自定义类型

2.变量定义 :变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。 基于变量的数据类型，解释器会分配指定内存，并决定什么数据可以被存储在内存中。 变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。（弱类型） 变量赋值 每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。（重要！！！） 等号（=）用来给变量赋值，等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。

try:
    print(x)
except NameError:
    print('NameError: "x" is not defined')　　#这个地方就会打印出x没有被定义


但是如果是实现对x进行赋值的话，就不会报错

try:
    x = 100
    print(x)
except NameError:
    print('NameError: "x" is not defined')   #这里直接输出100

二、常见字符串的处理：

　　0.python中string数据类型是不支持修改的　

import string
"""
    在python中，字符串是不可以被修改的
"""
s = 'abc'
print(s[0])
s[0] = 'x'
print(s)
这个地方会报错：TypeError: 'str' object does not support item assignment str对象不支持项目的赋值操作

　　1.去除空格及特殊符号：strip, lstrip, rstrip

去除空格操作，因为在python中字符串是不可以被修改的，所以在去除空格之后会返回一个新的字符串，而不是一个老的字符串，将老的字符串扔掉，

# 去除空格操作，因为在python中字符串是不可以被修改的，所以在去除空格之后会返回一个新的字符串，而不是一个老的字符串，将老的字符串扔掉，
s ='   abcd   e f g er f dfs dsf d f     '
print(s.strip())  #删除前后的空格 返回带有删除了前导和尾随空格的字符串副本。
print(s.lstrip()) #删除左边的空格  返回删除了前导空格的字符串副本。
print(s.rstrip())   #删除右边的空格
print(s)    #原来的字符串不会改变

　　2.复制字符串：str1 = str2

　　3.连接字符串 str2 += str1 new_str = str2 + str1

#字符串的连接
s1='abc'
s2='def'
print(s1+'\n'+s2)

　　4.字符串的大小写

#字符串的大小写
s = 'abc  def '
print(s.upper())  # upper()函数将所有的字母全部改成大写的
print(s.upper().lower())  #lower()函数将所有的字母改成小写

print(s.capitalize())  #实现字符串的首字母大写

　　5.字符串位置比较

#位置比较
s_1 = 'abcdefg'
s_2 = 'abdeffxx'
print(s_1.index('bcd'))
try:
    print(s_2.index('bcd'))
except ValueError:
    pass    #这里表示遇到这个异常什么都不做，继续做下去

Return the lowest index in S where substring sub is found, 
如果在字符串S中找到这个子字符串了，这个子串是包含在字符串S中，可选的参数start和end被解释为切片的方法，如果在找不到子串的时候，就会引发ValueError
such that sub is contained within S[start:end].  Optional
arguments start and end are interpreted as in slice notation.
Raises ValueError when the substring is not found.

　　在python3中cmp函数被移除了，字符串之间的比较，直接比较就可以了

# 字符串的比较
print(s_1==s_2)   # False
print(s_1<s_2)　　# True
print(s_1>s_2)　　#False

　　6.查找字符串：pos = str1.index(str2)

　　7.比较字符串：cmp(str1, str2)

　　8.字符串长度：len(str)

#查看字符串的长度 
print(len(''))   #空字符串在内存中还是分配了一个指针
print(len('abcdfdfsf sdf  asdf'))

　　9.字符串切割

# 字符串的分割和连接
s = 'abc,def,ghi'
splited = s.split(',')   #将字符串进行分割，分割的方式是按照逗号来进行分割
"""
     Return a list of the words in the string, using sep as the delimiter string.
    使用sep来作为字符串的分隔符，返回一个在字符串中的单词列表
          sep
            The delimiter according which to split the string.
            None (the default value) means split according to any whitespace,
            and discard empty strings from the result.
          sep:是进行字符串切割的分隔符，None表示根据空白来进行切割，并且从结果中丢弃空白的字符串
          
          maxsplit
            Maximum number of splits to do.
            -1 (the default value) means no limit.
          最大切割：
            将要切割的最大数量    -1表示没有限制  
"""
print(type(splited))  #
print(splited)

s = """abc
def
ghi
jkl """
s_1 = s.split('\n')　　#将字符串按照换行符来进行分割
print(s_1)　　　　　　　　
s_2 = s.splitlines()
print(s_2) #返回字符串中的行列表，在行边界处断开。除非给出了keepends，否则换行符不包含在结果列表中

　　10.字符串的连接

# 本方法将字符串组合回去
s = ['abc','def','ghi']
print(''.join(s))  # 连接符什么都不使用
print('#'.join(s))  #中间的连接符是#
print('\n'.join(s))  #中间使用换行符进行连接

　　11.对字符串的常用判断

# 字符串的常用判断
s='abcdefghi'
print(s.startswith('a'))   #判断字符串是不是以a为开头的
print(s.endswith('hi'))   #判断字符串是不是以hi结尾的

print('1234abcd'.isalnum())   #true 如果这个字符串是一个alpha-numeric字符串的话就返回True，否则就返回False
　　　　　　　　　　　　　　　　　　　#如果一个字符串中所有的字符都是按照字母表的顺序的字符串，并且在字符串中至少有一个字符，那么就是alpha-numeric字符串

print('1234abwcd\t'.isalnum())   #true  判断这个字符串中是不是只有0-9和a-z之间的字符的话就返回True
print('123dsf'.isalpha())  #判断是不是只有字符没有数字的情况
print('123abc'.isdigit())
print('12345'.isdigit())   #判断是不是只有纯数字的情况
print('   '.isspace())  #判断是不是只有space
print('abcd1234'.islower())  #判断字符串是不是都是小写的
print('aAabcd1234'.islower())  #如果字符都是小写的就返回True
print('aAabcd1234'.isupper())
print('AVCD'.isupper())   #判断字符串是不是都是大小的
print('Avvv'.istitle())  #判断是不是标题,即是在一个字符串中只有首字母是大写的，其他字符串都是小写的
print('ASSSdsf'.istitle())   #False
print('Hello World'.istitle())  #True   每个单词的首字母都是大写的

　　12.将数字转换为字符串

print(str(5))   #将int值转换为字符串
print(str(5.))  #将float型数值转换为字符串
print(type(str(5.234)))
print(str(-5.123))

　　13.将字符串转换为数字

#将字符串转换为数字
print(int('12345'))     # 整数字符换可以自动的转换为整数值
print(float(123.45))   # 浮点型的数值字符串也可以转换为浮点数
print(int('123.45'))  # 浮点型的字符串不能直接的转换为整数

print(int('ffff',16))  #指定转换的进制，将16进制转换为十进制的数值

　　14.作业：字符串按照单词反转，必须保留所有的空格  I Love china! 转换为china! Love I

三、条件判断

1.真值判断 if x == True:

　　　　 if x:

　　　　 if not x:

#if判断
a = 100
b =200
c = 300
if c==a:
    print(a)
elif c==b:
    print(c)
else:
    print(b)

 

2.空值判断 if x is None:

　　　　　  if not x:

#None的判断
x = None
if x is None:
    print('None')
else:
    print('Not None')

 

　　　比较  if a == b:

　　　　　　if a > b: ...

 四、循环控制

　　1.for循环

　　　　for i in range(begin, end, steps): <=> for (i = begin; i < end; i += steps)　

#for循环
# for i in range(0,30,5):   # 这个地方range(0,30,5)表示步长是从0开始，到30结束，步长是5，不包括最后一个元素
#     print(i)

 

　　2.while循环

　　　　while 条件判断:

#while循环
s= 0
i = 1
while i<=100:
    s+=i
    i+=1
print('s=',s)

for i in range(0,100):
    if i<10:
        pass #什么都不做
    elif i<30:
        continue    #什么都不做，跳出本次循环进入下一次循环
    elif i<35:
        print(i)
    else:
        break  # 到35的时候跳出本次循环

　　注意在python中：　

　　　　pass :不做任何事情，只起到占位的作用

　　　　continue: 跳出本次循环

　　　　break：结束循环

　　　　exit（）：结束整个程序

　　3.循环嵌套

　　4.循环控制：

　　　　break

　　　　continue

　　　　pass

五.函数

　　0.

def func_name(arg_1,arg_2):
    print(arg_1,arg_2)
    return arg_1,arg_2  #当返回多个值的时候，是返回的tuple，返回一个元组，只读的list

r= func_name(1,2)
print(type(r))   # r的数据类型是一个元组

　　

　　1.函数定义格式

　　　　(1)默认参数

def func(x,y=500):
    return x+y
print(func(200,600))
print(func(100))

　　　　注意在python参数的次序和声明可以不一致，这一点与C语言不一样，在python中随意调换

def func(x,y=500):
    print('x = ',x)
    print('y = ',y)
    return x+y
print(func(100))
print(func(y=300,x=200))
print(func(x=400))

 

　　　　(2)可变参数：*args，自动组装成tuple

　　　　　　可变参数传递进来之后，就自动打包成tuple，就是一个值不可变的数组

　　　　　　tuple:元组，等价于只读数组

def func(name,*numbers):  #这个可变参数就是告诉python程序，后面处理这个可变数组的时候，把数据放到这个可变数组中去
    print(type(numbers))
func('Tom',1,2,3,4,'tom','def')

def my_print(*args):  #这个*是告诉将*后面的内容撞到一个数组中去
    print(args)
my_print(1,2,3,4,5,6,'a','b','c')  #可变参数形成一个元组tuple

　　　　(3)关键字参数：*args，自动组装成dict

def func(name,**kvs):  #**后面的参数，在进行传递的时候，一定要将他的名字带上
    print(name)
    print(type(name)) #打印出name的数据类型
    print(type(kvs))  #打印出kvs的数据类型
    print(kvs)   #打印出kvs
func('Tom',china='BeiJing',uk='London')

def func(a,b,c,*,china,uk):
    print(china,uk)
func(1,2,3,china='BJ',uk='LD')

 

　　　　(4)命名关键字参数

# 可变参数
def func(a,b,c=0,*args,**kvs):
    print(a,b,c)
    print(args)
    print(kvs)
func(1,2)
func(1,2,3)
func(1,2,3,'a','b','c')
func(1,2,3,'a','b','c',)
func(1,2,3,'a','b',china='BJ',uk='LD')

 

　　2.函数调用

　　　　(1)函数名(参数名)

　　　　(2)模块名.函数名(参数名)

　　　　(3)带参数名调用

　　2. 什么是递归？

　　递归求和

def my_sum(i):
    if i<0:
        raise ValueError
    elif i<=1:
        return i
    else:
        return i+my_sum(i-1)

print(my_sum(1))
print(my_sum(2))
print(my_sum(3))
print(my_sum(4))
print(my_sum(100))

　　计算斐波那契数列

def fib(n):
    if n<1:
        raise ValueError
    elif n<=2:
        return 1
    else:
        return fib(n-1)+fib(n-2)

print(fib(1))
print(fib(2))
print(fib(3))
print(fib(4))
print(fib(5))
print(fib(40))

　　　　汉诺塔问题：

 汉诺塔问题
def hanoi(n,A,B,C):
    if n==1:   #如果只有一个盘子，直接将盘子移动到目标柱子上去
        print(A+'->'+B)
    else:
        hanoi(n-1,A,C,B)  # 如果盘子比较多的话，先将上面的n-1个盘子从source移动到source上去
        print(A+'->'+B)#再将底下的盘子移动到目标上去
        hanoi(n-1,C,A,B)

hanoi(4,'A','B','C')

　　在python中函数是可以作为参数的

 函数是可以作为参数的
def sum(x,y,P=None):
    s=x+y
    if P:
        P(s)
    return s
sum(100,200)
sum(100,200,print)  #这个地方将print以函数的形式进行传入