Python 基础

时间：2017-01-26 14:00:03 阅读：366 评论：0 收藏：0 [点我收藏+]

类：str是类，int是类，dict、list、tuple等等都是类，但是str却不能直接使用，因为它是抽象的表示了字符串这一类事物，并不能满足表示某个特定字符串的需求，我们必须要str1 = ‘‘初始化一个对象，这时的str1具有str的属性，可以使用str中的方法

type 可以查看代码的类型

>>> str1 = 123
>>> type(str1)
<class ‘int‘>
>>>

dir可以查看类的所有使用方法，刚开始学的时候先不看_xx_这些类型的方法

>>> str = [1,3,5]
>>> dir(str)
[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__delitem__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__gt__‘, ‘__hash__‘, ‘__iadd__‘, ‘__imul__‘, ‘__init__‘, ‘__init_subclass__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__reversed__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__setitem__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘]
>>>

　　append‘, ‘clear‘, ‘copy‘, ‘count‘, ‘extend‘, ‘index‘, ‘insert‘, ‘pop‘, ‘remove‘, ‘reverse‘, ‘sort‘主要看这些

append追加

count 统计

extend扩展

index索引

insert插入

pop删除最后一个

remove删除指定的一个

reverse反转

sort排序

>>> id_list =[1,2,4,56,56,5,888,56]
>>> id_list
[1, 2, 4, 56, 56, 5, 888, 56]
>>> id_list.append(‘23‘)
>>> id_list
[1, 2, 4, 56, 56, 5, 888, 56, ‘23‘]
>>> id_list.count(56)
3
>>> id_list.index(4)
2
>>> id_list
[1, 2, 4, 5, 56, 56, 56, 888, ‘23‘]
>>> for i in range(id_list.count(56)):
    id_list.remove(56)

    
>>> id_list
[1, 2, 4, 5, 888, ‘23‘]               //循环删除全部56

　　
_xxx_这些是python的私有方法后面再学习
　　在python中，还有一个“help(类名.方法名)”方法：可以查看类的详细功能；“help(类名.功能名)”：查看类中某功能的详细情况

  1 >>> help(str)
  2 Help on list object:
  3 
  4 class list(object)
  5  |  list() -> new empty list
  6  |  list(iterable) -> new list initialized from iterable‘s items
  7  |  
  8  |  Methods defined here:
  9  |  
 10  |  __add__(self, value, /)
 11  |      Return self+value.
 12  |  
 13  |  __contains__(self, key, /)
 14  |      Return key in self.
 15  |  
 16  |  __delitem__(self, key, /)
 17  |      Delete self[key].
 18  |  
 19  |  __eq__(self, value, /)
 20  |      Return self==value.
 21  |  
 22  |  __ge__(self, value, /)
 23  |      Return self>=value.
 24  |  
 25  |  __getattribute__(self, name, /)
 26  |      Return getattr(self, name).
 27  |  
 28  |  __getitem__(...)
 29  |      x.__getitem__(y) <==> x[y]
 30  |  
 31  |  __gt__(self, value, /)
 32  |      Return self>value.
 33  |  
 34  |  __iadd__(self, value, /)
 35  |      Implement self+=value.
 36  |  
 37  |  __imul__(self, value, /)
 38  |      Implement self*=value.
 39  |  
 40  |  __init__(self, /, *args, **kwargs)
 41  |      Initialize self.  See help(type(self)) for accurate signature.
 42  |  
 43  |  __iter__(self, /)
 44  |      Implement iter(self).
 45  |  
 46  |  __le__(self, value, /)
 47  |      Return self<=value.
 48  |  
 49  |  __len__(self, /)
 50  |      Return len(self).
 51  |  
 52  |  __lt__(self, value, /)
 53  |      Return self<value.
 54  |  
 55  |  __mul__(self, value, /)
 56  |      Return self*value.n
 57  |  
 58  |  __ne__(self, value, /)
 59  |      Return self!=value.
 60  |  
 61  |  __new__(*args, **kwargs) from builtins.type
 62  |      Create and return a new object.  See help(type) for accurate signature.
 63  |  
 64  |  __repr__(self, /)
 65  |      Return repr(self).
 66  |  
 67  |  __reversed__(...)
 68  |      L.__reversed__() -- return a reverse iterator over the list
 69  |  
 70  |  __rmul__(self, value, /)
 71  |      Return self*value.
 72  |  
 73  |  __setitem__(self, key, value, /)
 74  |      Set self[key] to value.
 75  |  
 76  |  __sizeof__(...)
 77  |      L.__sizeof__() -- size of L in memory, in bytes
 78  |  
 79  |  append(...)
 80  |      L.append(object) -> None -- append object to end
 81  |  
 82  |  clear(...)
 83  |      L.clear() -> None -- remove all items from L
 84  |  
 85  |  copy(...)
 86  |      L.copy() -> list -- a shallow copy of L
 87  |  
 88  |  count(...)
 89  |      L.count(value) -> integer -- return number of occurrences of value
 90  |  
 91  |  extend(...)
 92  |      L.extend(iterable) -> None -- extend list by appending elements from the iterable
 93  |  
 94  |  index(...)
 95  |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
 96  |      Raises ValueError if the value is not present.
 97  |  
 98  |  insert(...)
 99  |      L.insert(index, object) -- insert object before index
100  |  
101  |  pop(...)
102  |      L.pop([index]) -> item -- remove and return item at index (default last).
103  |      Raises IndexError if list is empty or index is out of range.
104  |  
105  |  remove(...)
106  |      L.remove(value) -> None -- remove first occurrence of value.
107  |      Raises ValueError if the value is not present.
108  |  
109  |  reverse(...)
110  |      L.reverse() -- reverse *IN PLACE*
111  |  
112  |  sort(...)
113  |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
114  |  
115  |  ----------------------------------------------------------------------
116  |  Data and other attributes defined here:
117  |  
118  |  __hash__ = None

View Code

> 左边大于右边

>= 左边大于等于右边

< 左边小于右边

<= 左边小于等于右边

== 左边等于右边

!= 左边不等于右边

int 　　整型

Long 　　长整型

　　现在的操作系统大部分int类型的表示范围是2^32,而长整形就是2^64，在python里，不需要程序员手动的转换int和long的数据类型，当数值的大小超过了int的表示范围，python会自动将数据类型转换为long型

Float 　　浮点型

　　浮点数用来处理实数，即带有小数的数字，类似于c语音中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号

布尔值：

　　真或假　　

　　1或0

　　0 = false

　　1 = true

使用变量之前，需要对其先赋值

变量名不能以数字开头

区分大小写

等号（=）是赋值的意思左边是名字右边是值不能写反

input 打印并要求用户输入

TAB 很重要！

数字判断大小代码接受input 后要变成整形 int

number = input (‘请输入1到100之间的数字：‘)

num = int(number)

第一个python程序

name = input(‘name:‘)
age = input(‘age:‘)
job =input(‘job:‘)

print(‘information of []:‘ +name +‘\n Name:‘+name+‘\nage:‘+age+‘\njob:‘+job)
print(‘information %s: \nName: %s \nage: %s\njob: %s‘ %(name,name,age,job))
#如果用‘‘‘
sss
sss
sss
‘‘‘
就不要\n换行了

字符串是%s;整数 %d；浮点数%f

不过一般都是用%s

字符串常用功能：

移除空白能使用 .strip()脱去（）括号里的空白

分割

长度

索引

切片

猜luckyNumber：

　　（最多猜3次）while循环

 1 guessConunt = 0
 2 while guessConunt<3:
 3     luckyNumber = int(input("please input your lucky number:"))
 4     #if (luckyNumber == 66):
 5      #   print(‘Bingo‘)
 6       #  break
 7     if(luckyNumber > 66):
 8         print(‘大了大了~‘)
 9     elif(luckyNumber<66):
10         print(‘小了小了~‘)
11     else :
12         print(‘Bingo‘)
13         break
14     guessConunt += 1
15 else:
16     print(‘so many too retry‘)

for循环

 1 for i in range(3):
 2     luckyNumber = int(input("please input your lucky number:"))
 3     #if (luckyNumber == 66):
 4      #   print(‘Bingo‘)
 5       #  break
 6     if(luckyNumber > 66):
 7         print(‘大了大了~‘)
 8     elif(luckyNumber<66):
 9         print(‘小了小了~‘)
10     else :
11         print(‘Bingo‘)
12         break
13 else:
14     print(‘so many too retrys‘)

元组tuple

元组等于列表除了只读

List（）将元组转换成list

%取模—返回除法的余数

**　　幂—返回x的y次幂

//　　去整除-返回商的整数部分

&与运算只要一个为假就为假

|或运算只要一个为真就为真

^异或运算一真一假就为真

逻辑运算符

　　and 　　布尔“与”-如果x为false，x and y 返回false，否则他返回y的计算值。

　　or 　　布尔“或”-如果x为TRUE，他返回TRUE，否则他返回y的计算值。

　　not　　布尔“非”-如果x为TRUE，返回false。如果x为false，他返回true。

成员运算符

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

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

身份运算符

身份运算符用于比较两个对象的存储单元

　　is 　　is是判断两个标识符是不是引用自一个对象

　　is not　　is not是判断两个标识符是不是引用自不同对象

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

简单的for循环

1 for i in range(10):
2     if i<5:
3         continue
4     print(i)

ps：Continue 跳出本次循环继续下次循环（i<5跳过）

Break 跳出这一层的整个循环

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

文件操作：

打开文件：

　　file_obj=open("文件路径",“模式”)

打开文件的模式有：

　　1.　　r，以只读的方式打开文件

　　2.　　w，打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

　　3.　　a，打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被添加至最后。如果该文件不存在，创建新文件进行写入。

　　4.　　w+，打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。

读取文件的内容

　　一次性加载所以内容到内存

obj.read()

　　一次性加载所以内容到内存，并跟根据行分割成字符串

obj.readlines()

　　每次仅读取一行数据

for line in obj:

　　print line

Python 基础

原文：http://www.cnblogs.com/S-zh/p/6351525.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)